2. Allen F., Babus A. Networks in finance. - 2008.

3. Balaji S., Swaminathan V., Kannan K. A simple algorithm to optimize maximum independent set //Advanced Modeling and Optimization. - 2010. - Т. 12. - №. 1. - С. 107-118.

4. Bautin G. A., Kalyagin V.A., Koldanov A.P., Koldanov P., Pardalos P.M.. Simple measure of similarity for the market graph construction //Computational Management Science. - 2013. - Т. 10. - №. 2-3. - С. 105-124.

5. Boginski V., Butenko S., Pardalos P. M. On structural properties of the market graph //Innovations in financial and economic networks. - 2003. - С. 29-45.

6. Boginski V., Butenko S., Pardalos P. M. Statistical analysis of financial networks //Computational statistics & data analysis. - 2005. - Т. 48. - №. 2. - С. 431-443.

7. Boginski V., Butenko S., Pardalos P. M. Mining market data: a network approach //Computers & Operations Research. - 2006. - Т. 33. - №. 11. - С. 3171-3184.

8. Bomze I. M. et al. The maximum clique problem //Handbook of combinatorial optimization. - Springer US, 1999. - С. 1-74.

9. Brunato M., Hoos H. H., Battiti R. On effectively finding maximal quasi-cliques in graphs //Learning and Intelligent Optimization. - Springer Berlin Heidelberg, 2008. - С. 41-55.

10. Elliott M., Golub B., Jackson M. O. Financial networks and contagion //Available at SSRN 2175056. - 2014.

11. Gai P., Kapadia S. Contagion in financial networks //Proceedings of the Royal Society of London A: Mathematical, Physical and Engineering Sciences. - The Royal Society, 2010. - С. rspa20090410.

12. Koldanov A. P. et al. Statistical procedures for the market graph construction //Computational Statistics & Data Analysis. - 2013. - Т. 68. - С. 17-29.

13. Liu G., Wong L. Effective pruning techniques for mining quasi-cliques //Machine Learning and Knowledge Discovery in Databases. - Springer Berlin Heidelberg, 2008. - С. 33-49.

14. Mantegna R., Stanley H. E. An Introduction to Econophysics: Correlations and Complexity in Finance, 2000 //Cambridge University Press, Cambridge. Citado. - 2005. - Т. 7. - С. 26-34.

15. Michael R. G., David S. J. Computers and intractability: a guide to the theory of NP-completeness //WH Freeman & Co., San Francisco. - 1979.

16. Pajouh F. M., Miao Z., Balasundaram B. A branch-and-bound approach for maximum quasi-cliques //Annals of Operations Research. - 2014. - Т. 216. - №. 1. - С. 145-161.

17. Pattillo J. et al. On the maximum quasi-clique problem //Discrete Applied Mathematics. - 2013. - Т. 161. - №. 1. - С. 244-257.

18. Soffer S. N., Vazquez A. Network clustering coefficient without degree-correlation biases //PHYSICAL REVIEW-SERIES E-. - 2005. - Т. 71. - №. 5. - С. 057101.

19. Vizgunov A. et al. Network approach for the Russian stock market //Computational Management Science. - 2014. - Т. 11. - №. 1-2. - С. 45-55.

20. Zeng Z. et al. Coherent closed quasi-clique discovery from large dense graph databases //Proceedings of the 12th ACM SIGKDD international conference on Knowledge discovery and data mining. - ACM, 2006. - С. 797-802.

21. Буренин А.Н. Рынок ценных бумаг и производных финансовых инструментов: учеб. пособие / А. Н. Буренин; Ин-т "Открытое общество". - М.: 1 Федеративная Книготорговая Компания, 1998. - 348 с. - ISBN 5-7814-0070-2.

22. Визгунов А.Н., Трифонов Ю. В. Применение модели графа доходностей для анализа фондового рынка //ВЕСТНИК НИЖЕГОРОДСКОГО УНИВЕРСИТЕТА ИМ. НИ ЛОБАЧЕВСКОГО. - 2013. - №. 6-1.

23. Задача о клике // Википедия. [2013--2013]. Дата обновления: 14.03.2013. URL: http://ru.wikipedia.org/?oldid=53537169 (дата обращения: 14.03.2013).

24. Кудрин А., Правительства PФ З. П. Россия и мировой финансовый кризис //Вопросы экономики. - 2009. - №. 1. - С. 7-10.

25. Медвежье царство Ведомости (FT) № 193 (2215) 13 октября 2008

26. НИЯЗБЕКОВА Ш. У. Становление и развитие фондового рынка в Российской Федерации и Республике Казахстан //ИЗВЕСТИЯ ОРЕНБУРГСКОГО ГОСУДАРСТВЕННОГО АГРАРНОГО УНИВЕРСИТЕТА. - 2014. - №. 1.



Приложение

Приложение 1

Программный код.

Парсер входных данных Parser.java:

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.collections.map.MultiValueMap;

import au.com.bytecode.opencsv.CSV;

import au.com.bytecode.opencsv.CSVReadProc;

public class Parser extends Base {

public static HashMap<String, double[]> rentMap = new HashMap<String, double[]>();

public static MultiValueMap mvMap = new MultiValueMap();

public static MultiValueMap[] mvMapArr = new MultiValueMap[11];

public static String[] indexes; // ordered indexes

public static double rentPerDay(double current, double previous) {

return Math.log(current / previous);

}

public static double rentMean(double... rents) {

double rentMean = 0;

if (rents.length > 0) {

for (double curr: rents) {

rentMean += curr;

}

return rentMean / rents.length;

}

return 0;

}

public static double var(double... rents) {

double var = 0;

double mean = rentMean(rents);

for (double curr: rents) {

var += Math.pow(curr - mean, 2);

}

return var / rents.length;

}

public static double[] arrayMult(double[] first, double[] second) {

double[] result = new double[first.length];

if (first.length == second.length) {

for (int i = 0; i < first.length; i++) {

result[i] = first[i] * second[i];

}

}

return result;

}

public static String[] getIndexes() {

return indexes;

}

public static double[] countRents(double[] prices) {

int l = prices.length - 1;

double[] result = new double[l];

result[0] = 1;

for (int i = 0; i < l; i++) {

result[i] = rentPerDay(prices[i + 1], prices[i]);

// System.out.print("R" + i + "=" + result[i] + " ");

}

// System.out.println();

return result;

}

public static double[][] cor(HashMap<String, double[]> rentM, String[] inds) {

debugn("Correlations:");

// logn("- corrs start time");

int l = inds.length;

double[][] result = new double[l][l];

for (int i = 0; i < l; i++) {

for (int j = 0; j < l; j++) {

if (inds[i] == inds[j]) {

result[i][j] = 0;

} else {

double[] rents1 = rentM.get(inds[i]);

double[] rents2 = rentM.get(inds[j]);

result[i][j] = (rentMean(arrayMult(rents1, rents2)) - rentMean(rents1)

* rentMean(rents2))

/ Math.sqrt(var(rents1) * var(rents2));

}

}

}

// logn("- corrs finish time");

return result;

}

public static double[] convertDoubles(Object doubles) {

List<Double> dbs = (List<Double>) doubles;

int i = 0;

double[] ret = new double[dbs.size()];

Iterator<Double> iterator = dbs.iterator();

while (iterator.hasNext()) {

ret[i] = iterator.next().doubleValue();

i++;

}

return ret;

}

public static MultiValueMap[] parseCSV(String filename, String startDate1,

String endDate1, String startDate2, String endDate2,

String startDate3, String endDate3, String startDate4,

String endDate4, String startDate5, String endDate5,

String startDate6, String endDate6, String startDate7,

String endDate7, String startDate8, String endDate8,

String startDate9, String endDate9, String startDate10,

String endDate10, String startDate11, String endDate11)

throws ParseException {

log("Parsing CSV file");

final SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");

final Date dateStart1 = sdf.parse(startDate1);

final Date dateEnd1 = sdf.parse(endDate1);

final Date dateStart2 = sdf.parse(startDate2);

final Date dateEnd2 = sdf.parse(endDate2);

final Date dateStart3 = sdf.parse(startDate3);

final Date dateEnd3 = sdf.parse(endDate3);

final Date dateStart4 = sdf.parse(startDate4);

final Date dateEnd4 = sdf.parse(endDate4);

final Date dateStart5 = sdf.parse(startDate5);

final Date dateEnd5 = sdf.parse(endDate5);

final Date dateStart6 = sdf.parse(startDate6);

final Date dateEnd6 = sdf.parse(endDate6);

final Date dateStart7 = sdf.parse(startDate7);

final Date dateEnd7 = sdf.parse(endDate7);

final Date dateStart8 = sdf.parse(startDate8);

final Date dateEnd8 = sdf.parse(endDate8);

final Date dateStart9 = sdf.parse(startDate9);

final Date dateEnd9 = sdf.parse(endDate9);

final Date dateStart10 = sdf.parse(startDate10);

final Date dateEnd10 = sdf.parse(endDate10);

final Date dateStart11 = sdf.parse(startDate11);

final Date dateEnd11 = sdf.parse(endDate11);

for (int k = 0; k < 11; k++) {

mvMapArr[k] = new MultiValueMap();

}

CSV csv = CSV.separator(';') // delimiter of fields

.quote('"') // quote character

.create(); // new instance is immutable

out(".");

csv.read(filename, new CSVReadProc() {

public void procRow(int rowIndex, String... values) {

try {

if (sdf.parse(values[1]).compareTo(dateStart1) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd1) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[0].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart2) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd2) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[1].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart3) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd3) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[2].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart4) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd4) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[3].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart5) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd5) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[4].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart6) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd6) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[5].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart7) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd7) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[6].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart8) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd8) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[7].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart9) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd9) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[8].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart10) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd10) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[9].put(values[0], Double.valueOf(s));

}

}

if (sdf.parse(values[1]).compareTo(dateStart11) >= 0

&& sdf.parse(values[1]).compareTo(dateEnd11) <= 0) {

// debugn("i="+i);

if (null != values[2] && !values[2].isEmpty()) {

String s = values[2].replaceAll(",", ".");

mvMapArr[10].put(values[0], Double.valueOf(s));

}

}

} catch (NumberFormatException | ParseException e) {

e.printStackTrace();

}

}

});

out(".\n");

return mvMapArr;

}

public static double[][] parseData(MultiValueMap mvMap) {

indexes = new String[mvMap.keySet().size()];

// Iterate using keys

Iterator iter = mvMap.keySet().iterator();

int i = 0;

while (iter.hasNext()) {

indexes[i] = iter.next().toString();

// debugn("indexes[" + i + "]: " + indexes[i]);

i++;

}

for (int k = 0; k < indexes.length; k++) {

// debugn("mvMap: " + mvMap.get(indexes[k]));

rentMap.put(indexes[k],

countRents(convertDoubles(mvMap.get(indexes[k]))));

}

double[][] corrs = cor(rentMap, indexes);

// print graph

int indi;

int indj = 0;

for (double[] d: corrs) {

indi = 0;

for (double s: d) {

if (s > 0.5) {

debug(indexes[indi] + " and " + indexes[indj] + "; ");

} else {

// logDebug(0 + " ");

}

indi++;

}

indj++;

debugn("");

}

out(".");

return corrs;

}

}

Вспомогателный файл Base.java для логирования в различных форматах:

import java.text.DateFormat;

import java.text.SimpleDateFormat;

public abstract class Base {

private static boolean DEBUG = false;

private static DateFormat formatter = new SimpleDateFormat("HH:mm:ss:SSS");

public static void log(String text) {

System.out.print(formatter.format(System.currentTimeMillis()) + ": " + text);

}

public static void logn(String text){

System.out.println(formatter.format(System.currentTimeMillis()) + ": " + text);

}

public static void debug(String text){

if(DEBUG){

System.out.print(text);

}

}

public static void debugn(String text){

if(DEBUG){

System.out.println(text);

}

}

public static void out(String text){

System.out.print(text);

}

}

Вспомогательный файл Parameters.java для работы алгоритма:

import java.util.ArrayList;

import java.util.List;

public class Parameters {

private int degree;

private List<String> adjVertices;

public Parameters(){

degree=0;

adjVertices=new ArrayList<String>();

}

public Parameters(int degree, List<String> adjVertices){

this.degree=degree;

this.adjVertices=adjVertices;

}

public void setDegree(int degree){

this.degree=degree;

}

public int getDegree(){

return degree;

}

public void addAdjVertex(String vert){

this.adjVertices.add(vert);

}

public void addAdjVerteces(List<String> adjVertices){

this.adjVertices.addAll(adjVertices);

}

public List<String> getAdjVertices(){

return adjVertices;

}

public String toString(){

return "degree=" + degree + " adjVertices="+ adjVertices.toString();

}

}

Основной файл QuasiCliqueFinder.java содержит эвристику поиска квази-клик, набор входных данных и обработку результатов:

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Random;

import java.util.Set;

import java.util.TreeMap;

import org.apache.commons.collections.map.MultiValueMap;

public class QuasiCliqueFinder extends Base {

public static double CORRELATION_THRESHOLD = 0.5;

public static double DENSITY_THRESHOLD = 1;

public static double calculateDensity(int edgescount, int vertexcount) {

return (double) edgescount / ((vertexcount * (vertexcount - 1)) / 2);

}

public static void printGraph(int[][] graph, String[] indexes) {

System.out.print("\t");

for (int i = 0; i < indexes.length; i++) {

System.out.print(indexes[i] + "\t");

}

System.out.println();

int indj = 0;

for (int[] d: graph) {

System.out.print(indexes[indj] + "\t");

for (int s: d) {

System.out.print(s + "\t");

}

indj++;

System.out.println();

}

}

private static int[][] cutCorrs(double[][] corrs, double threshold) {

int l = corrs.length;

int[][] result = new int[l][l];

int indi;

int indj = 0;

for (double[] d: corrs) {

indi = 0;

for (double s: d) {

if (s > threshold) {

result[indi][indj] = 1;

} else {

result[indi][indj] = 0;

}

indi++;

}

indj++;

}

return result;

}

public static void main(String[] args) throws ParseException {

/*

* logn("Simple test data:"); String[] indexes = new String[] { "1",

* "2", "3", "4", "5", "6", "7", "8" }; int[][] multi = new int[][] { {

* 0, 1, 1, 0, 0, 0, 1, 0 },// 1 { 1, 0, 1, 0, 0, 0, 0, 1 },// 2 { 1, 1,

* 0, 0, 0, 0, 0, 1 },// 3 { 0, 0, 0, 0, 0, 0, 0, 1 },// 4 { 0, 0, 0, 0,

* 0, 0, 0, 1 },// 5 { 0, 0, 0, 0, 0, 0, 0, 0 },// 6 { 1, 0, 0, 0, 0, 0,

* 0, 1 },// 7 { 0, 1, 1, 1, 1, 0, 1, 0 } // 8 }; List<String> clique =

* findQuasiClique(multi, indexes, ""); logn("quasi clique = " +

* clique.toString());

*/

// logn("Market data:");

// Table of correlations

MultiValueMap[] mvMapArr = Parser.parseCSV("data1.csv", "01.09.2007",

"11.09.2009", "13.11.2007", "23.11.2009", "31.01.2008",

"09.02.2010", "14.04.2008", "22.04.2010", "27.06.2008",

"06.07.2010", "05.09.2008", "14.09.2010", "21.11.2008",

"24.11.2010", "09.02.2009", "11.02.2011", "22.04.2009",

"26.04.2011", "06.07.2009", "08.07.2011", "14.09.2009",

"16.09.2011");

log("Preparing 11 market graphs for analysis");

double[][][] corrs = new double[11][][];

int[][][] marketGraph = new int[11][][];

for (int c = 0; c < 11; c++) {

corrs[c] = Parser.parseData(mvMapArr[c]);

marketGraph[c] = cutCorrs(corrs[c], CORRELATION_THRESHOLD);

}

out("\n");

for (int q = 0; q < 11; q++) {

int maxsize = 0;

// int counter = 0;

List<List<String>> maxclique = new ArrayList<List<String>>();

for (String s: Parser.indexes) {

for (int i = 0; i < 100; i++) {

List<String> qclique = findQuasiClique(marketGraph[q],

Parser.indexes, s);

if (qclique.size() > maxsize) {

maxsize = qclique.size();

maxclique = new ArrayList<List<String>>();

maxclique.add(qclique);

// counter = 1;

} else if (qclique.size() == maxsize) {

// counter++;

maxclique.add(qclique);

}

}

}

// Sort items

for (int i = 0; i < maxclique.size(); i++) {

Collections.sort(maxclique.get(i));

}

Set<String> union = new HashSet<String>();

Set<List<String>> unique = new HashSet<List<String>>(maxclique);

Iterator iter = unique.iterator();

logn("Period=" + (q + 1) + ",Size=" + maxsize + ",Found="

+ unique.size());

int i = 0;

while (iter.hasNext()) {

List<String> curr = (List<String>) iter.next();

union.addAll(curr);

out("Quasi Clique[" + i + "]=" + curr + "\n");

i++;

}

List<String> sortedUnion = new ArrayList<String>(union);

Collections.sort(sortedUnion);

out("Union=" + sortedUnion + "\n");

out("Union Size=" + union.size() + "\n");

}

// out(maxsize+"\t");

logn("End of execution");

}

private static List<String> findQuasiClique(int[][] marketGraph,

String[] indexes, String startNode) {

// future result

List<String> clique = new ArrayList<String>();

int n_clique_e = 0;

// Getting degree of every vertex

Map<String, Parameters> vertexDegreesMap = getVerticesDegrees(

marketGraph, indexes);

Iterator<String> iter = vertexDegreesMap.keySet().iterator();

// int i = 0;

while (iter.hasNext()) {

String cur = iter.next().toString();

debug("[" + cur + ": " + vertexDegreesMap.get(cur).toString()

+ "]; ");

}

String startPoint = "";

List<String> currentArray = new ArrayList<String>();

// if start node is empty getting random, otherwise using suggested one

if (startNode.isEmpty()) {

out("Random start node will be used\n");

// Searching for max degree

Iterator<String> iter2 = vertexDegreesMap.keySet().iterator();

String maxDegName = "";

int maxDeg = 0;

while (iter2.hasNext()) {

String cur = iter2.next().toString();

if (vertexDegreesMap.get(cur).getDegree() > maxDeg) {

maxDeg = vertexDegreesMap.get(cur).getDegree();

maxDegName = cur;

}

}

debugn("\nName of max degree is " + maxDegName + "; Max degree is "

+ maxDeg);

// Getting 1 random vertex with degree higher then threshold

// threshold

double degreeThreshold = maxDeg / 2 + maxDeg / 4;

debugn("degreeThreshold: " + degreeThreshold);

Iterator<String> iter3 = vertexDegreesMap.keySet().iterator();

while (iter3.hasNext()) {

String cur = iter3.next().toString();

if (vertexDegreesMap.get(cur).getDegree() >= degreeThreshold) {

currentArray.add(cur);

// debug(cur + ", ");

}

}

debugn("currentArray1=" + currentArray.toString());

final Random random = new Random();

int index = random.nextInt(currentArray.size());

debugn("index=" + index);

startPoint = currentArray.get(index);

debugn("startPoint=" + startPoint);

} else {

startPoint = startNode;

}

// Add start node into the result

clique.add(startPoint);

// Update currentArray with only vertices adjusted to start node

currentArray = vertexDegreesMap.get(startPoint).getAdjVertices();

debugn("currentArray2=" + currentArray.toString());

// now we will be checking all nodes adjusted to our clique iteratively

// we will add only vertices that satisfy our density condition

while (true) {

Iterator<String> iter4 = currentArray.iterator();

List<String> accepted = new ArrayList<String>();

while (iter4.hasNext()) {

String curr = iter4.next();

// skip all node that are already in clique

if (!clique.contains(curr)) {

int numofadjverts = 0;

// check how much vertices from current clique are adjusted

// to current node

List<String> adjNodes = vertexDegreesMap.get(curr)

.getAdjVertices();

for (String s: adjNodes) {

if (clique.contains(s)) {

numofadjverts++;

}

}

// Checking if density condition is true and adding vertex

// to

// the list of accepted

if (n_clique_e != 0) {

debugn("Clique.size()=" + clique.size()

+ " n_clique_e=" + n_clique_e

+ " numofadjverts=" + numofadjverts);

debugn("Node=" + curr + ", Expected density="

+ (double) (2 * (n_clique_e + numofadjverts))

/ ((clique.size() + 1) * (clique.size())));

if ((double) (2 * (n_clique_e + numofadjverts))

/ ((clique.size() + 1) * (clique.size())) >= DENSITY_THRESHOLD) {

accepted.add(curr);

}

} else {

accepted.add(curr);

}

}

}

if (accepted.size() == 0) {

break;

}

// Getting one random vertex from accepted list and adding into the

// clique

// and also updating number of edges in our current clique

final Random random2 = new Random();

int index2 = random2.nextInt(accepted.size());

List<String> adjVerts2 = vertexDegreesMap.get(accepted.get(index2))

.getAdjVertices();

int numofadjverts = 0;

for (String s: adjVerts2) {

if (clique.contains(s)) {

numofadjverts++;

}

}

// we prevent adding in the list nodes that are already their so

// it should be safe just to add new node

clique.add(accepted.get(index2));

// number of edges in graph is increased on number of new

// connections

n_clique_e += numofadjverts;

debugn("n_clique_e = " + n_clique_e);

debugn("clique = " + clique.toString());

Iterator<String> adjIter = vertexDegreesMap

.get(accepted.get(index2)).getAdjVertices().iterator();

while (adjIter.hasNext()) {

String curr = adjIter.next();

if (!currentArray.contains(curr)) {

currentArray.add(curr);

}

}

}

return clique;

}

private static Map<String, Parameters> getVerticesDegrees(

int[][] marketGraph, String[] indexes) {

Map<String, Parameters> resultMap = new TreeMap<String, Parameters>();

Parameters params;

int indi;

int indj = 0;

for (int[] d: marketGraph) {

params = new Parameters();

indi = 0;

for (int s: d) {

if (s == 1) {

params.addAdjVertex(indexes[indi]);

params.setDegree(params.getDegree() + 1);

}

indi++;

}

resultMap.put(indexes[indj], params);

indj++;

}

return resultMap;

}

}

Размещено на Allbest.ru

...