IPB
ЛогинПароль:

> Внимание!

1. Пользуйтесь тегами кода. - [code] ... [/code]
2. Точно указывайте язык, название и версию компилятора (интерпретатора).
3. Название темы должно быть информативным.
В описании темы указываем язык!!!

Наладить общение поможет, если вы подпишитесь по почте на новые темы в этом форуме.

 
 Ответить  Открыть новую тему 
> с си в паскаль, помогите нужен зачет
сообщение
Сообщение #1





Группа: Пользователи
Сообщений: 4
Пол: Мужской
Реальное имя: Алексей

Репутация: -  0  +


// lb-sim-batch
// © A.C. Kaporis, L.K. Kirousis, and E.C. Stavropoulos, 2006
//
// Purpose:
//
// Computes the maximum cut of a random generated graph G in G(n,m)
// from average degree dl to average degree du, with step dstep
// n=2^k is the number of nodes of G
// m=d*n/2 is the number of edges of G
//
// Syntax:
//
// lb-sim-batch [k] [dl] [du] [step] [output file name]
// k is the exponent of a power of 2, while
// dl is the lower value of average degree of G
// du is the upper value of average degree of G
// dstep is the value of increasing the average degree of G
// The output is directed to output file name (also to the standand output)
//
// Output format:
//
// number of nodes, average degree, and the maximum cut of graph G
//
// Reference paper:
//
// A.C. Kaporis, L.K. Kirousis, and E.C. Stavropoulos,
// Approximating almost all instances of Max-Cut within a ratio above the H{\aa}stad threshold.
// In Proc. of ESA 2006, LNCS 4168, pp. 432--443, 2006
//


#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>


#define UNCOLORED -1
#define RED 0
#define BLUE 1
#define MAXVARS 100

typedef struct _Tneigh
{
int who;
struct _Tneigh *next;
} Tneigh;

typedef struct
{
Tneigh *neigh;
int degree;
} Tnode;

typedef struct
{
int neighcolored[2];
int mycolor;
} Tnodecolor;

Tnode *nodes;
Tnodecolor *nodecolors;

int k, numofnodes, numofedges;
double c, cl, cu, cstep;
double d, dl, du, dstep;

FILE *fp;
int decimation_cut=0;


void *alloc (size_t n)
{
void *ret;

ret = malloc(n);
if (ret == 0)
{
printf ("out of memory! Exiting...\n");
exit(0);
}
return (ret);
}

int randomnumber (int size)
{
return (rand() % size);
}

void initgraph ()
{
int i;

nodes = (Tnode *) alloc (numofnodes*sizeof (Tnode));
nodecolors = (Tnodecolor *) alloc (numofnodes*sizeof(Tnodecolor));

for (i=0;i<numofnodes;++i)
{
nodes[i].degree = 0;
nodes[i].neigh = 0;
}

}

void freegraph ()
{
int i;
Tneigh *p, *pnext;

for (i=0;i<numofnodes;++i)
{
p=nodes[i].neigh;
while (p)
{
pnext = p->next;
free (p);
p=pnext;
}
}

free (nodes);
free (nodecolors);
}

void randomgraph ()
{
int i, distinct, endpoint1, endpoint2;
Tneigh *p, *prev;

for (i=0;i<numofedges;++i)
{
endpoint1 = randomnumber (numofnodes);
distinct = 0;
while (!distinct)
{
endpoint2 = randomnumber (numofnodes);
if (endpoint2 != endpoint1)
distinct = 1;
}
if (nodes[endpoint1].degree == 0)
{
nodes[endpoint1].neigh = (Tneigh *) alloc (sizeof(Tneigh));
nodes[endpoint1].neigh->who = endpoint2;
nodes[endpoint1].neigh->next = 0;
}
else
{
p = nodes[endpoint1].neigh;
while (p)
{
prev = p;
p = p->next;
}
p = (Tneigh *) alloc (sizeof(Tneigh));
prev->next = p;
p->who = endpoint2;
p->next = 0;
}
nodes[endpoint1].degree++;

if (nodes[endpoint2].degree == 0)
{
nodes[endpoint2].neigh = (Tneigh *) alloc (sizeof(Tneigh));
nodes[endpoint2].neigh->who = endpoint1;
nodes[endpoint2].neigh->next = 0;
}
else
{
p = nodes[endpoint2].neigh;
while (p)
{
prev = p;
p = p->next;
}
p = (Tneigh *) alloc (sizeof(Tneigh));
prev->next = p;
p->who = endpoint1;
p->next = 0;
}
nodes[endpoint2].degree++;
}

for (i=0;i<numofnodes;++i)
{
nodecolors[i].mycolor = UNCOLORED;
nodecolors[i].neighcolored[RED] = 0;
nodecolors[i].neighcolored[BLUE] = 0;
}
}

int countcut ()
{
int i,cut;

cut =0;
for (i=0;i<numofnodes;++i)
if (nodecolors[i].mycolor == BLUE)
cut += nodecolors[i].neighcolored[RED];
return (cut);

}


//delete edge (endpoint1, endpoint2) where deg(endpoint1)=0
void delete_edge(int endpoint1, int endpoint2)
{
Tneigh *p, *pnext;
int found=0;

if (nodes[endpoint1].degree == 1)
nodes[endpoint1].neigh = 0;
nodes[endpoint1].degree--;

if (nodes[endpoint2].degree == 1)
nodes[endpoint2].neigh = 0;
else{
if (nodes[endpoint2].neigh->who == endpoint1)
nodes[endpoint2].neigh = nodes[endpoint2].neigh->next;
else
{
p=nodes[endpoint2].neigh;
while(!found){
pnext = p->next;
if (pnext->who == endpoint1){
found=1;
p->next = pnext->next;
}
else
p=p->next;
}
}
}
nodes[endpoint2].degree--;
}//delete_edge


void decimation()
{
Tneigh *p;
int i,j;

int endpoint1, endpoint2;
for (j=0; j<numofnodes; j++)
for (i=0;i<numofnodes;++i){
if (nodes[i].degree == 1) {
endpoint1 = i;
p=nodes[i].neigh;
endpoint2 = p->who;
delete_edge(endpoint1, endpoint2);
decimation_cut++;
}
}
}


//////////////////////////////////////////////////////////////////////////////
///////////////////////// Coloring Algorithm /////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void color_ESA2006 ()
{
int i,j,n;
int discrepancy;
int max_discrepancy = -1;
int uncolored_degree;
int min_uncolored_degree = numofedges;
int numofcolorednodes = 0;

Tneigh *p;

for (i=0;i<numofnodes;++i)
{
nodecolors[i].mycolor = UNCOLORED;
nodecolors[i].neighcolored[RED] = 0;
nodecolors[i].neighcolored[BLUE] = 0;
}

while (numofcolorednodes < numofnodes)
{

//color all nodes with uncolored_degree=0
for (j=0;j<numofnodes;++j)
{
if (nodecolors[j].mycolor == UNCOLORED )
{
uncolored_degree = nodes[j].degree - nodecolors[j].neighcolored[BLUE] - nodecolors[j].neighcolored[RED];
if (uncolored_degree == 0) //color it now
{
n = j;
numofcolorednodes++;
//printf("%d \t color node %d with uncolored_degree %d \n", numofcolorednodes, n, uncolored_degree);
if (nodecolors[n].neighcolored[RED] > nodecolors[n].neighcolored[BLUE])
{
nodecolors[n].mycolor = BLUE;
p=nodes[n].neigh;
while (p)
{
nodecolors[p->who].neighcolored[BLUE]++;
p=p->next;
}
}
else if (nodecolors[n].neighcolored[RED] < nodecolors[n].neighcolored[BLUE])
{
nodecolors[n].mycolor = RED;
p=nodes[n].neigh;
while (p)
{
nodecolors[p->who].neighcolored[RED]++;
p=p->next;
}
}
else
{
nodecolors[n].mycolor = randomnumber (2);
p=nodes[n].neigh;
while (p)
{
nodecolors[p->who].neighcolored[nodecolors[n].mycolor]++;
p=p->next;
}
}
}
}
}


// find an uncolored node with max discrepancy
max_discrepancy = -1;
for (j=0;j<numofnodes;++j)
{
if (nodecolors[j].mycolor == UNCOLORED && nodes[j].degree > 1)
{
discrepancy = abs(nodecolors[j].neighcolored[BLUE]-nodecolors[j].neighcolored[RED]);
if (discrepancy > max_discrepancy)
{
n = j;
max_discrepancy = discrepancy;
}
}
}

//find an uncolored node with max_discrepancy having the minimun number of uncolored neighbors
min_uncolored_degree = numofedges;
for (j=0;j<numofnodes;++j)
{
if (nodecolors[j].mycolor == UNCOLORED && nodes[j].degree > 1)
{
discrepancy = abs(nodecolors[j].neighcolored[BLUE]-nodecolors[j].neighcolored[RED]);
if (discrepancy == max_discrepancy)
{
uncolored_degree = nodes[j].degree-nodecolors[j].neighcolored[RED]-nodecolors[j].neighcolored[BLUE];
if (uncolored_degree < min_uncolored_degree)
{
min_uncolored_degree = uncolored_degree;
n = j;
}
}

}
}

//color node n
if (nodecolors[n].mycolor == UNCOLORED && nodes[n].degree > 1)
{
numofcolorednodes++;
if (nodecolors[n].neighcolored[RED] > nodecolors[n].neighcolored[BLUE])
{
nodecolors[n].mycolor = BLUE;
p=nodes[n].neigh;
while (p)
{
nodecolors[p->who].neighcolored[BLUE]++;
p=p->next;
}
}
else if (nodecolors[n].neighcolored[RED] < nodecolors[n].neighcolored[BLUE])
{
nodecolors[n].mycolor = RED;
p=nodes[n].neigh;
while (p)
{
nodecolors[p->who].neighcolored[RED]++;
p=p->next;
}
}
else
{
nodecolors[n].mycolor = randomnumber (2);
p=nodes[n].neigh;
while (p)
{
nodecolors[p->who].neighcolored[nodecolors[n].mycolor]++;
p=p->next;
}
}
}
}
}




//////////////////////////////////////////////////////////////////////////////
////////////////////////////////// MAIN //////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
int main(int argc,char *argv[])
{

if (argc != 6) {
printf("Syntax: lb-sim [k] [dl] [du] [dstep] [output file name] \n");
exit(1);
}

srand( (unsigned)time( NULL ) );

k = atoi(argv[1]);
numofnodes = (int) pow(2,k);

dl = atof(argv[2]);
cl = 0.5*dl;

du = atof(argv[3]);
cu = 0.5*du;

dstep = atof(argv[4]);
cstep = 0.5*dstep;

d = dl;
c = 0.5*d;


while (c < cu + cstep)
{
numofedges = (int) (c*numofnodes);

initgraph ();

randomgraph ();

decimation_cut=0;
decimation ();

color_ESA2006 ();

printf ("n=%d \t d=%4.1f \t cut=%10.8f \n",
numofnodes, 2.0*c, (double) (countcut()+ decimation_cut) / (double) numofedges);

fp = fopen(argv[5], "a");

fprintf (fp, "n=%d \t d=%4.1f \t cut=%10.8f \n",
numofnodes, 2.0*c, (double) (countcut()+ decimation_cut) / (double) numofedges);

fclose(fp);

freegraph();

c = c + cstep;
}

return 0;
}//main



вот эту программу очень нужно реализовать на паскале.помогите пожалуйста .зачёт очень нужен до понедельника :'-(
 Оффлайн  Профиль  PM 
 К началу страницы 
+ Ответить 
сообщение
Сообщение #2


Гость






Заходишь в Google, ищешь программу C2PAS (возможно есть и другие), прогоняешь через нее свой исходник, получаешь практически готовый исходник на Паскале, который придется только чуть-чуть подпилить...
 К началу страницы 
+ Ответить 

 Ответить  Открыть новую тему 
1 чел. читают эту тему (гостей: 1, скрытых пользователей: 0)
Пользователей: 0

 





- Текстовая версия 31.10.2020 15:49
500Gb HDD, 6Gb RAM, 2 Cores, 7 EUR в месяц — такие хостинги правда бывают
Связь с администрацией: bu_gen в домене octagram.name