12307130066_Xuan Yuan_Assignment12/13

12307130066/assignment12:13/A.cpp

@@ -0,0 +1,77 @@
+#include<iostream>
+#include<cstdio>
+#include<vector>
+
+using namespace std;
+struct edge {
+        int target;
+        int Distance;
+};
+
+edge links[10000][10000];
+int link_count[10000];
+int Distance[10000];
+int prevs[10000][10000][3];
+int prev_count[10000];
+int SUM = 0;
+
+void findWay(int index) {
+        if(index == 0)
+                return;
+        for(int i = 0; i < prev_count[index]; i++) {
+                if(prevs[index][i][2] == 0) {
+                        prevs[index][i][2] = 1;
+                        SUM += prevs[index][i][1];
+                        findWay(prevs[index][i][0]);
+                }
+        }
+}
+
+int main() {
+        int P, T;
+        scanf("%d%d", &P, &T);
+        for(int i = 0; i < P; i++) {
+                link_count[i] = 0;
+                prev_count[i] = 0;
+                Distance[i] = 10000000;
+        }
+        Distance[0] = 0;
+        int tmp1, tmp2, tmp3;
+        for(int i = 0; i < T; i++) {
+                scanf("%d%d%d", &tmp1, &tmp2, &tmp3);
+                if(tmp1 == tmp2)
+                	continue;
+                links[tmp1][ link_count[tmp1]++ ].target = tmp2;
+                links[tmp1][ link_count[tmp1]-1 ].Distance = tmp3;
+                links[tmp2][ link_count[tmp2]++ ].target = tmp1;
+                links[tmp2][ link_count[tmp2]-1 ].Distance = tmp3;
+        }
+        vector<int> queue;
+        vector<int> queue_currDistance;
+        queue.push_back(0);
+        queue_currDistance.push_back(0);
+        int curr = 0, tmp, tmpDistance;
+        while(curr < queue.size()) {
+                tmp = queue[curr++];
+                tmpDistance = queue_currDistance[curr-1];
+                for(int i = 0; i < link_count[tmp]; i++) {
+                        if(tmpDistance + links[tmp][i].Distance < Distance[ links[tmp][i].target ]) {
+                                Distance[ links[tmp][i].target ] = tmpDistance + links[tmp][i].Distance;
+                                prev_count[ links[tmp][i].target ] = 0;
+                                prevs[ links[tmp][i].target ][ prev_count[ links[tmp][i].target ]++ ][0] = tmp;
+                                prevs[ links[tmp][i].target ][ prev_count[ links[tmp][i].target ]-1 ][1] = links[tmp][i].Distance;
+                                prevs[ links[tmp][i].target ][ prev_count[ links[tmp][i].target ]-1 ][2] = 0;
+                                queue.push_back(links[tmp][i].target);
+                                queue_currDistance.push_back(Distance[ links[tmp][i].target ]);
+                        }
+                        else if(Distance[tmp] + links[tmp][i].Distance == Distance[ links[tmp][i].target ]) {
+                                prevs[ links[tmp][i].target ][ prev_count[ links[tmp][i].target ]++ ][0] = tmp;
+                                prevs[ links[tmp][i].target ][ prev_count[ links[tmp][i].target ]-1 ][1] = links[tmp][i].Distance;
+                                prevs[ links[tmp][i].target ][ prev_count[ links[tmp][i].target ]-1 ][2] = 0;
+                        }
+                }
+        }
+        findWay(P - 1);
+        cout << SUM * 2 << endl;
+        return 0;
+}

12307130066/assignment12:13/B.cpp

@@ -0,0 +1,54 @@
+#include<cstdio>
+using namespace std;
+struct Animal {
+        int parent;
+        int relation;
+};
+Animal animal[50010];
+
+int getRoot(int x) {
+        if(x!=animal[x].parent)
+        {
+                int fx=getRoot(animal[x].parent);
+                animal[x].relation=(animal[x].relation+animal[animal[x].parent].relation)%3;
+                animal[x].parent=fx;
+        }
+        return animal[x].parent;
+}
+
+bool merge(int X, int Y, int Type) {
+        int rX = getRoot(X);
+        int rY = getRoot(Y);
+        if(rX == rY && Type != (animal[Y].relation - animal[X].relation + 3) % 3) {
+                return false;
+        }
+        if(rX == rY) {
+                return true;
+        }
+        animal[rY].parent = rX;
+        animal[rY].relation = (animal[X].relation - animal[Y].relation + Type + 3) % 3;
+        return true;
+}
+
+int main() {
+        int N, K;
+        scanf("%d%d", &N, &K);
+        for(int i = 1; i <= N; i++) {
+                animal[i].parent = i;
+                animal[i].relation = 0;
+        }
+        int tmp1, tmp2, tmp3, count = 0;
+        for(int i = 0; i < K; i++) {
+                scanf("%d%d%d", &tmp1, &tmp2, &tmp3);
+                if(tmp2 > N || tmp3 > N || (tmp2 == tmp3 && tmp1 == 2)) {
+                        count++;
+                }
+                else {
+                        if(!merge(tmp2, tmp3, tmp1 - 1)) {
+                                count++;
+                        }
+                }
+        }
+        printf("%d\n", count);
+        return 0;
+}

12307130066/assignment12:13/C.cpp

@@ -0,0 +1,95 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+
+using namespace std;
+int father[550], m, k;
+double d[550];
+
+struct post
+{
+        double x, y;
+}p[550];
+
+struct edge
+{
+        int u, v;
+        double w;
+}e[500005];
+
+bool comp(edge e1, edge e2)
+{
+        return  e1.w < e2.w;
+}
+
+double get_dis(double x1, double y1, double x2, double y2)
+{
+        return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
+}
+
+void Init(int n)
+{
+        for(int i = 1; i <= n; i++)
+                father[i] = i;
+}
+
+int Find(int x)
+{
+        if(x != father[x])
+                father[x] = Find(father[x]);
+        return father[x];
+}
+
+void Merge(int a, int b)
+{
+        int p = Find(a);
+        int q = Find(b);
+        if(p > q)
+                father[p] = q;
+        else
+                father[q] = p;
+}
+
+void Kruskal(int n)
+{
+        k = 0;
+        double Max = 0;
+        for(int i = 0; i < m; i++)
+                if(Find(e[i].u) != Find(e[i].v))
+                {
+                        Merge(e[i].u, e[i].v);
+                        d[k++] = e[i].w;
+                        n--;
+                        if(n == 1)
+                                return;
+                }
+}
+
+int main()
+{
+        int t, S, P, i, j;
+        double x, y;
+        scanf("%d",&t);
+        while(t--)
+        {
+                m = 0;
+                scanf("%d%d",&S,&P);
+                Init(P);
+                for(i = 1; i <= P; i++)
+                        scanf("%lf%lf",&p[i].x, &p[i].y);
+                for(i = 1; i <= P; i++)
+                        for(j = i + 1; j <= P; j++)
+                        {
+                                e[m].u = i;
+                                e[m].v = j;
+                                e[m++].w = get_dis(p[i].x, p[i].y, p[j].x, p[j].y);
+                                e[m].u = j;
+                                e[m].v = i;
+                                e[m++].w = get_dis(p[i].x, p[i].y, p[j].x, p[j].y);
+                        }
+                sort(e, e+m, comp);
+                Kruskal(P);
+                printf("%.2lf\n",d[P-S-1]);
+        }
+        return 0;
+}