No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
Artificial intelligence in the maximum clique finding problem applications
Abstract
In this paper we propose collecting different maximum clique finding algorithms into a meta-algorithm, which enables to solve this NP-hard problem much more efficiently. We provide guidelines on how this intelligent meta-algorithm can be built, what information is needed from the maximum clique finding point of view and propose an elementary structure of it. Besides we review a test environment issue for the maximum clique finding area. This topic usually is undervalued, although enables to provide knowledge on algorithms behaviors and connections between algorithms and graph types, which later could be converted into the intelligent meta-algorithm's rules and definitions. We describe in this paper the test environment model, define each part of it and propose integration principles.
Clustering for high-dimension data streams is a main focus in the field of clustering research. In order to optimize the clustering process, especially for the large number of candidate subspaces generated in it, optimal segmentation section technology and FP-tree structure are introduced, based on which, DOIC (dynamic optimal intervals-based cluster) algorithm is proposed. In this paper, the memory-based data partition and optimal intervals division are defined to generate high-density grids for each dimension, which are stored in a high-density unit tree (HDU). The HDU-tree is built according to the principle that high-density grids for the same interval in every dimension are stored in the same branch. Thus the process of clustering high-dimension data streams is transformed into that of searching for dense grids in the HDU-tree. By merging HDU-trees, new data streams is inserted and historical data streams is decayed, then the updating of data streams is achieved. The clustering result is returned in the form of DNF expressions timely as requests. The experimental results demonstrate that DOIC has better space scalability and higher clustering quality compared with traditional clustering algorithms.
In this paper a question of using artificial intelligence principles and an incomplete solution approach were explored for solving NP hard problems in the real-time systems using the maximum clique finding problem as an example. The incomplete solution is used to analyze different best known algorithms in the real-time environment, while artificial intelligence principles were implemented in a form of a meta-algorithm containing other problem specific algorithms. Experiments conducted in this paper have demonstrated that the meta-algorithm in a randomly generated graphs environment required up to 3 times less time to find a solution in a certain range of graphs than the best known general type algorithm, and was never slower in other ranges.
In this paper we are reviewing how the maximum-weight clique problem is solved in the real-time systems' environment by the best-known algorithms. The real-time environment is a quite unique one applying interesting restrictions on algorithms to be used and is rarely considered by researches although a lot of applications are hosted there. The main conflict to be researched here is produced by a time complexity of the maximum-weight clique problem and the real-time systems' requirement to solve a case during a predefined time interval. In this article an "incomplete solution" approach is used to explore maximum-weight clique algorithms performance.
There is a permanent great interest in developing fast exact algorithms solving NP-hard problems like finding the maximum
clique, a vertex coloring and so forth. The testing step is an essential one in the process of inventing new algorithms and
can generate a lot of valuable information if it is built and used appropriately. The paper proposes methods and functionalities
that should be included into the testing tool. The high level idea is to use the testing process as a service for the algorithms
construction process by providing necessary feedback, i.e. have a concurrent cycle between the algorithm (mathematical) production
phase and the testing phase. Thereafter the paper discusses what kind artificial intelligence can be implemented into such
testing tool to increase the quality of results and vice versa - what the testing tool can produce for the artificial intelligence
algorithms targeted to solve NP-hard problems.
The paper discusses where the artificial intelligence principles can be applied in the graph theory NP-hard problems' algorithms in order to make those quicker and better. The paper aim is to concentrate different ideas on making graph algorithms to be intelligent in one place instead of leaving a research process in this area to be still chaotic. The artificial intelligence for the graph algorithms can be divided into an internal one, where the intelligence is a part of an algorithm, and an external, where it is used in a form of a meta-algorithm providing an infrastructure and handling other algorithms (dedicated for solving this particular NP-hard problem). Another classification can be done by NP-hard problems algorithms' elements to which the intelligence can be applied. Those can be summarised in a form of the following list: upper and lower bounds, algorithms' internal elements and techniques, a meta-algorithm intelligence deciding which algorithm to run on a particular graph, and a testing intelligence. It is possible to conclude that using the internal and external artificial intelligences can both improve the NP-hard problems algorithms' performance and produce adaptive algorithms that can be successfully used in different environments.
In this paper we present an exact algorithm for the maximum-weight clique problem on arbitrary undirected graphs. The algorithm based on a fact that vertices from the same independent set couldn't be included into the same maximum clique. Those independent sets are obtained from a heuristic vertex coloring where each of them is a color class. Color classes and a backtrack search are used for pruning branches of the maximum-weight clique search tree. Those pruning strategies together result in a very effective algorithm for the maximum-weight clique finding. Computational experiments with random graphs show that the new algorithm works faster than earlier published algorithms; especially on dense graphs.
A partially enumerative algorithm is presented for the maximum clique problem which is very simple to implement. Computational results for an efficient implementation on an IBM 3090 computer are provided for randomly generated graphs with up to 3000 vertices and over one million edges. Also provided are exact specifications for test problems to facilitate future comparisons. In addition, the Fortran 77 code of the proposed algorithm is given.
This paper presents an O(n log n) algorithm for finding a maximum independent set in a permutation graph.
Consider the execution of a parallel application that dynamically generates parallel jobs with specified resource requirements during its execution. We assume that there is not sufficient knowledge about the running times and the number of jobs generated in order to precompute a schedule for such applications. Rather, the scheduling decisions have to be made on-fine during runtime based on incomplete information. We present several on-line scheduling algorithms for various interconnection topologies that use some a priori information about the job running times or guarantee a good competitive ratio that depends on the runtime ratio of all generated jobs. All algorithms presented in this paper have optimal competitive ratio up to small additive constants.
Register allocation may be viewed as a graph coloring problem. Each node in the graph stands for a computed quantity that resides in a machine register, and two nodes are connected by an edge if the quantities interfere with each other, that is, if they are simultaneously live at some point in the object program. This approach, though mentioned in the literature, was never implemented before. Preliminary results of an experimental implementation in a PL/I optimizing compiler suggest that global register allocation approaching that of hand-coded assembly language may be attainable.
This paper presents some adaptive restart randomized greedy heuristics for MAXIMUM CLIQUE. The algorithms are based on improvements and variations of previously-studied algorithms by the authors. Three kinds of adaptation are studied: adaptation of the initial state (AI) given to the greedy heuristic, adaptation of vertex weights (AW) on the graph, and no adaptation (NA). Two kinds of initialization of the vertex-weights are investigated: unweighted initialization (w
i := 1) and degree-based initialization (w
i := d
i where d
i is the degree of vertex i in the graph). Experiments are conducted on several kinds of graphs (random, structured) with six combinations: {NA, AI, and AW} × {unweighted initialization, degree-based initialization. A seventh state of the art semi-greedy algorithm, DMclique, is evaluated as a benchmark algorithm. We concentrate on the problem of finding large cliques in large, dense graphs in a relatively short amount of time. We find that the different strategies produce different effects, and that different algorithms work best on different kinds of graphs.
This paper is a sample prepared to illustrate the use of the American Mathematical Society's L A T E X document class dimacs-l. Please be sure to read Section 3. It contains instructions for authors that apply specifically to volumes in the DIMACS series. Volume 61 of the DIMACS book series (Bioconsensus) is an example of a volume prepared using the guidelines contained herein. This is an unnumbered first-level section head This is an example of an unnumbered first-level heading. This is a special section head This is an example of a special section head .
Contents 1 Introduction 2 1.1 Notations and Definitions . . . . . . . . . . . . . . . . . . . . . . . . 3 2 Problem Formulations 4 2.1 Integer Programming Formulations . . . . . . . . . . . . . . . . . . . 5 2.2 Continuous Formulations . . . . . . . . . . . . . . . . . . . . . . . . 8 3 Computational Complexity 12 4 Bounds and Estimates 15 5 Exact Algorithms 19 5.1 Enumerative Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . 19 5.2 Exact Algorithms for the Unweighted Case . . . . . . . . . . . . . . 21 5.3 Exact Algorithms for the Weighted Case . . . . . . . . . . . . . . . . 25 6 Heuristics 27 6.1 Sequential Greedy Heuristics . . . . . . . . . . . . . . . . . . . . . . 28 6.2 Local Search Heuristics . . . . . . . . . . . . . . . . . . . . . . . . . 29 6.3 Advanced Search Heuristics . . . . . . . . . . . . . . . . . . . . . . . 30 6.3.1 Simulated annealing . . . . . . . . . . . . . . . . . . . . . . . 30 6.3.2 Neural networks . . . . . . . . . . . . . . . . . . . . . . . .
Consider the execution of a parallel application that dynamically generates parallel jobs with specified resource requirements
during its execution. We assume that there is not sufficient nowledge about the running times and the number of jobs generated
in order to precompute a schedule for such applications. Rather, the scheduling decisions have to be made on-line during runtime
based on incomplete information. We present several on-line scheduling algorithms for various interconnection topologies that
use some a priori information about the job running times or guarantee a good competitive ratio that depends on the runtime
ratio of all generated jobs. All algorithms presented in this paper have optimal competitive ratio up to small additive constants.
This paper presents an informal discussion of issues that arise when one attempts to analyze algorithms experimentally. It is based on lessons learned by the author over the course of more than a decade of experimentation, survey paper writing, refereeing, and lively discussions with other experimentalists. Although written from the perspective of a theoretical computer scientist, it is intended to be of use to researchers from all fields who want to study algorithms experimentally. It has two goals: first, to provide a useful guide to new experimentalists about how such work can best be performed and written up, and second, to challenge current researchers to think about whether their own work might be improved from a scientific point of view. With the latter purpose in mind, the author hopes that at least a few of his recommendations will be considered controversial.