main()
{
int choice,list_ele;
choice=0;
while(choice!=4)
{
printf("choices\n");
printf("for makeset 1 \n");
printf("for represtative 2 \n");
scanf("%d",&choice);
if(choice==1)
{
printf("enter the data \n");
scanf("%d",&list_ele);
head=makeset(&head,list_ele);
printf("%d\n",&head);
}
else if(choice==2)
{
printf("enter first linked list\n");
scanf("%d",&re);
k=return1(&head1,re);
t=represen(&k);
printf("%d\n",t);
}
}
}
void kruskalalgorithm()
{
struct edges e;
int r1,r2,u;
//heap->heapsort();
int edgesadded = 0;
for(int i=0;i<NO_OF_VERTICES;i++)
makeset(i);
while(edgesize > 0 && edgesadded < NO_OF_VERTICES-1)
{
e = heap->extractmax();
r1 = find(e.u);
r2 = find(e.v);
//cout<<" u value is "<<e.u<<" v is "<<e.v<<" wt is "<<e.edgeweight<<" r1 is "<<r1<<" r2 is "<<r2<<endl;
if(r1 != r2 && edgesadded < NO_OF_VERTICES-1)
{
edgesadded++;
//cout<<" u is "<<e.u<<" v is "<<e.v<<" wt is "<<e.edgeweight<<" r1 is "<<r1<<" r2 is "<<r2<<endl;
maxspanningtree[(e.u)*NO_OF_VERTICES+(e.v)] = e.edgeweight;
maxspanningtree[(e.v)*NO_OF_VERTICES+(e.u)] = e.edgeweight;
merge(r1,r2);
}
}
}
/*
Given an angularly ordered tree (vertices), construct a set of contours where
each contour describe a branch of the tree.
*/
vector<ContourEQW>
extractPathTree(vector<Vertex<FragmentInfo>*>& vertices,
vector<ContourEQW>& contours)
{
vector<ContourEQW> tree;
vector<Node<Vertex<FragmentInfo>*>*> vnodes;
for(int i=0; i<vertices.size(); ++i)
{
vnodes.push_back(makeset(vertices[i]));
}
vector<Vertex<FragmentInfo>*> ends = findEndPoints(vertices);
for(int i=0; i<ends.size(); ++i)
{
Vertex<FragmentInfo>* p = ends[i];
vector<Vertex<FragmentInfo>*> path;
while(true)
{
path.push_back(p);
if(p->pi == NULL)
{
break;
}
int k = distance(vertices.begin(), find(vertices.begin(), vertices.end(), p->pi));
if(k < vnodes.size() && vnodes[k]->parent == vnodes[k])
{
merge(vnodes[i], vnodes[k]);
p = p->pi;
}
else
{
path.push_back(p->pi);
break;
}
}
tree.push_back(stitchContour(path, contours));
}
for(int i=0; i<vnodes.size(); ++i)
{
delete vnodes[i];
vnodes[i] = 0;
}
return tree;
}
int main()
{
int n,m;
int a,b;
int i;
scanf("%d %d",&n,&m);
for(i=0;i<n;++i)
{
makeset(i);
}
int flag = 0;
for(i=0;i<m;++i)
{
scanf("%d %d",&a,&b);
flag = union_set(a,b);
if(flag == -1) break;
}
if(flag == -1) printf("NO\n");
else printf("YES\n");
}
vector<int>
labelIntraFramePoints(vector<MotionPoint*>& points)
{
vector<Node<int>*> vnodes;
for (int i = 0; i < points.size(); ++i)
{
vnodes.push_back(makeset(i));
}
for (int i = 0; i < points.size(); ++i)
{
for (int j = i + 1; j < points.size(); ++j)
{
//if (i == j) continue;
for (int m = 0; m < points[i]->candidates.size(); ++m)
{
for (int n = 0; n<points[j]->candidates.size(); ++n)
{
//if (points[i].GetLink(j, m, n) > .5) {
if (points[i]->getLink(m, j, n) > 0.5) //probLink[j][m][n] > .5)
{
merge(vnodes[i], vnodes[j]);
}
}
}
}
}
vector<Node<int>*> labels = clusters(vnodes);
vector<int> ilabels(points.size());
for (int i = 0; i < points.size(); ++i)
{
ilabels[i] = distance(labels.begin(), find(labels.begin(), labels.end(), findset(vnodes[i])));
}
for (int i = 0; i < points.size(); ++i)
{
delete vnodes[i];
}
return ilabels;
}
int main()
{
int i;
while (scanf("%d%d%d",&n,&m,&q)!=EOF)
{
memset(count,0,sizeof(count));
makeset(n,m);
for (i=1;i<=q;i++)
{
char name[10];
scanf("%s%d%d",name,&opt[i].x,&opt[i].y);
opt[i].s=name[0];
switch (opt[i].s)
{
case 'C':scanf("%d%d",&opt[i].l,&opt[i].c); break;
case 'D':scanf("%d%d",&opt[i].l,&opt[i].c); break;
case 'R':scanf("%d%d%d",&opt[i].l,&opt[i].w,&opt[i].c); break;
case 'T':scanf("%d%d",&opt[i].w,&opt[i].c); break;
}
}
for (i=q;i>0;i--)
{
switch (opt[i].s)
{
case 'C':Cir(opt[i].x,opt[i].y,opt[i].l,opt[i].c); break;
case 'D':Dia(opt[i].x,opt[i].y,opt[i].l,opt[i].c); break;
case 'R':Rec(opt[i].x,opt[i].y,opt[i].l,opt[i].w,opt[i].c); break;
case 'T':Tri(opt[i].x,opt[i].y,opt[i].w,opt[i].c); break;
}
}
for (i=1;i<=9;i++)
if (i==9) printf("%d\n",count[i]);
else printf("%d ",count[i]);
}
return 0;
}
int main(int argc, char **argv)
{
int maxprims, maxfigs, maxpts, state, maxindivs, namelen;
int nfigs, nprims, npts, setsize, iters;
int ext;
struct Individ *indivs, tmp;
struct Figure *figs, *figset;
char *str;
ssize_t chread;
size_t n;
int i, j, k, m, nindivs;
struct NestAttrs attrs;
str = NULL;
n = 0;
maxfigs = 128;
namelen = 2048;
state = STATE_NEWFIG;
nfigs = nprims = npts = 0;
figs = (struct Figure*)xmalloc(sizeof(struct Figure) * maxfigs);
while ((chread = getline(&str, &n, stdin)) != -1) {
double x, y;
trim(str);
if (state == STATE_NEWFIG) {
figs[nfigs].name = (char*)xmalloc(sizeof(char) * namelen);
sscanf(str, "%s %d %d\n", figs[nfigs].name, &figs[nfigs].quant, &figs[nfigs].angstep);
state = STATE_PRIM;
maxpts = 2048;
maxprims = 128;
figs[nfigs].prims = (struct Primitive*)xmalloc(sizeof(struct Primitive) * maxprims);
figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
// free(str);
str = NULL;
continue;
}
if (strcmp(str, FIG_SEPAR) == 0) {
state = STATE_NEWFIG;
figs[nfigs].prims[nprims].npts = npts;
nprims++;
figs[nfigs].id = nfigs;
figs[nfigs].nprims = nprims;
nfigs++;
if (nfigs == maxfigs) {
maxfigs *= 2;
figs = (struct Figure*)xrealloc(figs, sizeof(struct Figure) * maxfigs);
}
nprims = 0;
npts = 0;
// free(str);
str = NULL;
continue;
}
if (strcmp(str, PRIM_SEPAR) == 0) {
figs[nfigs].prims[nprims].npts = npts;
nprims++;
if (nprims == maxprims) {
maxprims *= 2;
figs[nfigs].prims = (struct Primitive*)xrealloc(figs[nfigs].prims, sizeof(struct Primitive) * maxprims);
}
maxpts = 2048;
figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
npts = 0;
// free(str);
str = NULL;
continue;
}
sscanf(str, "%lf %lf\n", &x, &y);
figs[nfigs].prims[nprims].pts[npts].x = x;
figs[nfigs].prims[nprims].pts[npts].y = y;
npts++;
if (npts == maxpts) {
maxprims *= 2;
figs[nfigs].prims[nprims].pts = (struct Point*)xrealloc(figs[nfigs].prims[nprims].pts, sizeof(struct Point) * maxpts);
}
// free(str);
str = NULL;
}
for (i = 0; i < nfigs; i++) {
figinit(&figs[i]);
}
attrs.width = atof(argv[1]);
attrs.height = atof(argv[2]);
attrs.type = ROTNEST_DEFAULT;
attrs.logfile = fopen("./logfile", "w+");
figset = makeset(figs, nfigs, &setsize);
qsort(figset, setsize, sizeof(struct Figure), figcmp);
maxindivs = 1024;
indivs = (struct Individ*)xmalloc(sizeof(struct Individ) * maxindivs);
indivs[0].genom = (int*)xmalloc(sizeof(int) * setsize);
indivs[0].gensize = 0;
rotnest(figset, setsize, &indivs[0], &attrs);
nindivs = 1;
ext = 0;
iters = atoi(argv[3]);
for (i = 0; i < iters && !ext; i++) {
int nnew = 0, equal = 0, oldn;
printf("nindivs=%d\n", nindivs);
for (j = 0; j < 1; j++) {
printf("ind=%d height=%lf gensize=%d genom: ", i, indivs[j].height, indivs[j].gensize);
for (k = 0; k < indivs[j].gensize; k++) {
printf("%d ", indivs[j].genom[k]);
}
printf("\n");
}
printf("\n");
oldn = nindivs;
for (j = 0; j < oldn - 1 && nnew < 30; j++) {
struct Individ heirs[2];
if (indivs[j].gensize == indivs[j + 1].gensize) {
int res;
res = crossover(&indivs[j], &indivs[j + 1], &heirs[0], setsize);
crossover(&indivs[j + 1], &indivs[j], &heirs[1], setsize);
if (res < 0) {
break;
}
}
else {
break;
}
for (k = 0; k < 2; k++) {
for (m = 0; m < nindivs; m++) {
equal = gensequal(&heirs[k], &indivs[m]) || gensequal2(&heirs[k], &indivs[m], figset);
if (equal) {
break;
}
}
if (!equal) {
nnew++;
rotnest(figset, setsize, &heirs[k], &attrs);
indivs[nindivs] = heirs[k];
nindivs++;
if (nindivs == maxindivs) {
maxindivs *= 2;
indivs = (struct Individ*)xrealloc(indivs, sizeof(struct Individ) * maxindivs);
}
} else {
destrindiv(&heirs[k]);
}
}
}
equal = 0;
while (nnew == 0) {
int res;
res = mutate(&indivs[0], &tmp, setsize);
if (res < 0) {
ext = 1;
break;
}
equal = 0;
for (j = 0; j < nindivs; j++) {
equal = gensequal(&tmp, &indivs[j]) || gensequal2(&tmp, &indivs[j], figset);
if (equal) {
break;
}
}
if (!equal) {
nnew++;
rotnest(figset, setsize, &tmp, &attrs);
indivs[nindivs] = tmp;
nindivs++;
if (nindivs == maxindivs) {
maxindivs *= 2;
indivs = (struct Individ*)xrealloc(indivs, sizeof(struct Individ) * maxindivs);
}
} else {
destrindiv(&tmp);
}
}
qsort(indivs, nindivs, sizeof(struct Individ), gencmp);
}
for (i = 0; i < indivs[0].npos; i++) {
double a, b, c, d, e, f;
a = indivs[0].posits[i].fig.mtx[0][0];
b = indivs[0].posits[i].fig.mtx[1][0];
c = indivs[0].posits[i].fig.mtx[0][1];
d = indivs[0].posits[i].fig.mtx[1][1];
e = indivs[0].posits[i].fig.mtx[0][2];
f = indivs[0].posits[i].fig.mtx[1][2];
printf("%s\n", indivs[0].posits[i].fig.name);
printf("matrix(%lf, %lf, %lf, %lf, %lf, %lf)\n:\n", a, b, c, d, e, f);
}
// ppos2file("./drawposits", indivs[0].posits, indivs[0].npos);
return 0;
}
int main()
{
int edges;
int vertices;
int i=0, j=0, weight = 0, v1, v2, w;
scanf("%d%d",&vertices,&edges);
struct dslist v[vertices];
struct edges e[edges];
struct edges S[edges];
int temp = edges;
while(edges){
--edges;
scanf("%d%d%d",&v1,&v2,&w);
e[i].start = v1;
e[i].end = v2;
e[i].weight = w;
i++;
}
first = NULL;
last = NULL;
struct dslist *node;
node = first;
for(i=0; i<vertices; i++)
{ struct ds *nd;
nd = (struct ds *) malloc (sizeof (struct ds));
nd->key = i;
nd->p = NULL;
nd->rank = 0;
struct dslist *ndstr;
ndstr = (struct dslist *) malloc (sizeof (struct dslist));
ndstr->elem = nd;
ndstr->next = NULL;
if(first == NULL)
{first = ndstr;
first->next = NULL;
last = first;}
else{
last->next = ndstr;
last = ndstr;
}
makeset(nd);
};
insertionsort(e, temp);
for(i=0;i<temp; i++)
{
if((find(retpoint(e[i].start)))->key != (find(retpoint(e[i].end)))->key)
{ S[j] = e[i];
j++;
combine(retpoint(e[i].start), retpoint(e[i].end));
}
}
//printf("\n SORTED:");
for(i=0; i<j; i++)
{ weight += S[i].weight;
//printf("%d %d",S[i].start,S[i].end);
}
printf("WEIGHT: %d\n",weight);
print_matrix(S, vertices);
return 0;
}
Triangulator::Triangulator(const vector<CParticleF>& pnts)
{
for(int i=0; i<pnts.size(); ++i)
{
points.push_back(new _Internal::_vertex(pnts[i]));
}
vector<TriangulateBourke::Triplet> delaunayTriangles = TriangulateBourke::DelaunayTriangulation(pnts);
/*if(tripletSanityCheck(delaunayTriangles, pnts.size()) > 0)
{
int i=0;
}*/
for(int i=0; i<delaunayTriangles.size(); i++)
{
int xk = delaunayTriangles[i].index[0];
int yk = delaunayTriangles[i].index[1];
int zk = delaunayTriangles[i].index[2];
assert(xk>=0 && xk<pnts.size() && yk>=0 && yk<pnts.size() && zk>=0 && zk<pnts.size());
CParticleF x = pnts[xk];
CParticleF y = pnts[yk];
CParticleF z = pnts[zk];
float ccw = CounterClockWise(x, y, z);
if(ccw > 0)
{
//arrange them in clockwise orientation
swap(xk, zk);
swap(x, z);
}
_Internal::_edge* tedges[3];
tedges[0] = (new _Internal::_edge(points[xk], points[yk]));
tedges[1] = (new _Internal::_edge(points[yk], points[zk]));
tedges[2] = (new _Internal::_edge(points[zk], points[xk]));
_Internal::_triangle* tr = new _Internal::_triangle(0, 0, 0, points[xk], points[yk], points[zk]);
faces.push_back(tr);
//add new edges to the edge vector. Make association with a new face and edges.
for(int j=0; j<3; ++j)
{
vector<_Internal::_edge*>::iterator it = find_if(edges.begin(), edges.end(), _Internal::_edge_equal(tedges[j]));
if(it == edges.end())
{
edges.push_back(tedges[j]);
}
else
{
delete tedges[j];
tedges[j] = *it;
}
tr->edges[j] = tedges[j];
tedges[j]->AddFace(tr);
}
points[xk]->AddEdge(tedges[0]);
points[xk]->AddEdge(tedges[2]);
points[yk]->AddEdge(tedges[0]);
points[yk]->AddEdge(tedges[1]);
points[zk]->AddEdge(tedges[1]);
points[zk]->AddEdge(tedges[2]);
}
sort(edges.begin(), edges.end(), _Internal::_edge_less);
//classify each edge. Initially, they are either Inside or Boundary.
//After edge-removal, we can have Hole edges when an Inside edge is removed.
for(int i=0; i<edges.size(); ++i)
{
if(isBoundary(edges[i]))
{
edges[i]->type = _Internal::Boundary;
}
else
{
edges[i]->type = _Internal::Inside;
}
Node<_Internal::_edge*>* node = makeset(edges[i]);
vnodes.push_back(node);
edges[i]->node = node;
}
//make a cluster of boundary edges. Initially, there is only one cluster
Node<_Internal::_edge*>* root = NULL;
for(int i=0; i<edges.size(); ++i)
{
if(edges[i]->type == _Internal::Boundary)
{
if(root == NULL)
{
root = edges[i]->node;
}
else
{
merge(edges[i]->node, root);
}
}
}
}
