1 #include<stdio.h>
 2 #include<iostream>
 3 #include<string.h>
 4 #include<queue>
 5 using namespace std;
 6 #define N 8000
 7 #define inf 0x7ffffff
 8 vector<int>g[N];
 9 int n, id[N],last[N];
10 
11 struct node {
12     int k;
13     node(int a = 0) : k(a) {}
14     bool operator<(const node & r) const { return r.k<k; }
15 };
16 priority_queue<node>q;
17 
18 int main() {
19     int k;
20     n = 0;
21     memset(last, -1, sizeof (last));
22     while (scanf("%d", &k) != EOF) { id[n] = k; last[k] = n++; }
23     n++; while (!q.empty()) q.pop();
24     for (int i = 1; i <= n; i++) {
25         if (last[i] == -1) q.push(node(i));
26         g[i].clear();
27     }
28     for (int i = 0; i < n - 1; i++) {
29         k = q.top().k; q.pop();
30         g[k].push_back(id[i]);
31         g[id[i]].push_back(k);
32         if (i == last[id[i]]) q.push(node(id[i]));
33     }
34     for (int i = 1; i <= n; i++) {
35         printf("%d:", i);
36         sort(g[i].begin(), g[i].end());
37         for (int j = 0; j < g[i].size(); j++)
38             printf(" %d", g[i][j]);
39         puts("");
40     }
41     return 0;
42 }

晓天_xiaotian 2010-10-09 10:26 发表评论

 1 /*
 2  * File:   PKU 3635 Full Tank?
 3  * Author: xiaotian @ hnu
 4  * Created on 2010年10月8日, 下午4:27
 5  * 题解：优先队列bfs
 6  */
 7 #include<iostream>
 8 #include<math.h>
 9 #include<queue>
10 #include<stdio.h>
11 #include<algorithm>
12 #include<string.h>
13 #include<vector>
14 using namespace std;
15 #define N 1008
16 #define inf 0x7fffffff
17 
18 struct node {
19     int v, dist;
20 
21     node(int a = 0, int b = 0) : v(a), dist(b) {
22     }
23 };
24 
25 struct Node {
26     int v,rest,cost;
27 
28     Node(int a = 0, int b = 0, int c = 0) : v(a), rest(b), cost(c) {
29     }
30     bool operator<(const Node &r) const{
31         return r.cost < cost;
32     }
33 };
34 vector<node>g[N];
35 int dp[N][102];
36 bool vist[N][102];
37 int n, m, a[N], V, S, T, ans;
38 priority_queue<Node>q;
39 
40 int bfs() {
41     int x, y, z;
42     while (!q.empty())
43         q.pop();
44     q.push(Node(S, 0, 0));
45     dp[S][0] = 0;
46     while (!q.empty()) {
47         Node p = q.top();
48         q.pop();
49         x = p.v, y = p.rest, z = p.cost;
50         vist[x][y] = 1;
51         if (x == T) return z;
52         if (y + 1 <= V && !vist[x][y + 1] && dp[x][y + 1] > dp[x][y] + a[x]) {
53             dp[x][y + 1] = dp[x][y] + a[x];
54             q.push(Node(x, y + 1, dp[x][y + 1]));
55         }
56         for (int i = 0; i < g[x].size(); i++) {
57             int t = g[x][i].v;
58             int k = y - g[x][i].dist;
59             if (k >= 0 && !vist[t][k] && z < dp[t][k]) {
60                 dp[t][k] = z;
61                 q.push(Node(t, k, dp[t][k]));
62             }
63         }
64     }
65     return -1;
66 }
67 
68 int main() {
69     int i, j;
70     while (scanf("%d%d", &n, &m) != EOF) {
71         for (i = 0; i < n; i++) {
72             scanf("%d", &a[i]);
73             g[i].clear();
74         }
75         int u, v, w;
76         for (i = 0; i < m; i++) {
77             scanf("%d%d%d", &u, &v, &w);
78             g[u].push_back(node(v, w));
79             g[v].push_back(node(u, w));
80         }
81         int tc;
82         scanf("%d", &tc);
83         while (tc--) {
84             scanf("%d%d%d", &V, &S, &T);
85             memset(vist, 0, sizeof (vist));
86             for (i = 0; i < n; i++)
87                 for (j = 0; j <= 100; j++)
88                     dp[i][j] = inf;
89             ans = bfs();
90             if (ans == -1)
91                 printf("impossible\n");
92             else
93                 printf("%d\n", ans);
94         }
95     }
96     return 0;
97 }

晓天_xiaotian 2010-10-08 17:08 发表评论

晓天_xiaotian 2010-10-08 10:21 发表评论

 1 /* 
 2  * File:   HNU 10862 Ticket to Ride
 3  * Author: xiaotian @ hnu
 4  * Created on 2010年10月6日, 下午7:48
 5  * 题解：最小斯泰纳树，直接套板
 6  */
 7 
 8 #include<stdio.h>
 9 #include<iostream>
10 #include<string>
11 #include<queue>
12 #include<map>
13 #include<set>
14 #include<math.h>
15 using namespace std;
16 #define N 1000
17 #define A 8
18 #define inf 0x7ffffff
19 int vis[N], id[A]; //id[]: A中点的标号
20 int d[N][N], dp[1 << A][N]; //dp[i][v]: 点v到点集i的最短距离
21 map<string, int>mp, fg;
22 
23 int min(int a, int b) {
24     return a < b ? a : b;
25 }
26 
27 void steiner(int n, int a) {
28     int i, j, k, mx, mk, top = (1 << a);
29     for (k = 0; k < n; k++)
30         for (i = 0; i < n; i++)
31             for (j = 0; j < n; j++)
32                 if (d[i][j] > d[i][k] + d[k][j])
33                     d[i][j] = d[i][k] + d[k][j];
34     for (i = 0; i < a; i++) { // vertex: 0 ~ n-1
35         for (j = 0; j < n; j++)
36             dp[1 << i][j] = d[j][ id[i] ];
37     }
38     for (i = 1; i < top; i++) {
39         if (0 == (i & (i - 1))) continue;
40         memset(vis, 0, sizeof (vis));
41         for (k = 0; k < n; k++) { // init
42             for (dp[i][k] = inf, j = 1; j < i; j++)
43                 if ((i | j) == i &&
44                         dp[i][k] > dp[j][k] + dp[i - j][k])
45                     dp[i][k] = dp[j][k] + dp[i - j][k];
46         }
47         for (j = 0; mx = inf, j < n; j++) { // update
48             for (k = 0; k < n; k++)
49                 if (dp[i][k] <= mx && 0 == vis[k])
50                     mx = dp[i][mk = k];
51             for (k = 0, vis[mk] = 1; k < n; k++)
52                 if (dp[i][mk] > dp[i][k] + d[k][mk])
53                     dp[i][mk] = dp[i][k] + d[k][mk];
54         }
55     }
56 }
57 
58 int main() {
59     int n, m, a = 8, w;
60     char s1[25], s2[25];
61     while (scanf("%d%d\n", &n, &m) != EOF) {
62         if (n == 0 && m == 0) return 0;
63         mp.clear();
64         for (int i = 0; i < n; i++) {
65             scanf("%s",s1);
66             mp[s1] = i + 1;
67         }
68         for (int i = 0; i <= n; i++)
69             for (int j = 0; j <= n; j++) d[i][j] = i==j?0:inf;
70         for (int i = 0; i < m; i++) {
71             scanf("%s %s %d", s1, s2, &w);
72             int u = mp[s1] - 1;
73             int v = mp[s2] - 1;
74             d[u][v] = d[v][u] = min(d[u][v], w);
75         }
76         fg.clear();
77         for (int i = 0; i < 8; i++) {
78             scanf("%s", s1);
79             id[i] = mp[s1] - 1;
80         }
81         steiner(n, a);
82         int i, j, z, x, y, k, b;
83         for (i = 0, b = inf; z = 0, i < 256; b > z ? b = z : b, i++)
84             for (j = 0; y = 0, j < 4; z += !!y * dp[y][x], j++)
85                 for (k = 0; k < 8; k += 2)
86                     if ((i >> k & 3) == j)
87                         y += 3 << k, x = id[k];
88         printf("%d\n",b);
89     }
90 }

晓天_xiaotian 2010-10-06 20:57 发表评论

 1 #include<stdio.h>
 2 #include<iostream>
 3 #include<string.h>
 4 #include<queue>
 5 #include<map>
 6 #include<set>
 7 #include<math.h>
 8 using namespace std;
 9 #define N 5008
10 #define inf 0x7ffffff
11 vector<int> g[N];
12 int cnt, low[N], pre[N], vis[N], deg[N];
13 void dfs(int u, int v) {
14     vis[u] = 1;
15     pre[u] = cnt++, low[u] = pre[u];
16     for (int i = 0; i < g[u].size(); ++i) {
17         if (g[u][i] == v) continue;
18         if (!vis[g[u][i]]) dfs(g[u][i], u);
19         if (low[g[u][i]] < low[u]) low[u] = low[g[u][i]];
20     }
21     vis[u] = 2;
22 }
23 int ok(int x, int y) {
24     for (int i = 0; i < g[x].size(); ++i)
25         if (y == g[x][i]) return 0;
26     return 1;
27 }
28 int main() {
29     int i, j, u, v, n, m, ans;
30     while (scanf("%d %d", &n, &m) != EOF) {
31         for (i = 0; i <= n; ++i) g[i].clear();
32         while (m--) {
33             scanf("%d %d", &u, &v);
34             if (ok(u, v)) {
35                 g[u].push_back(v);
36                 g[v].push_back(u);
37             }
38         }
39         memset(vis, 0, sizeof (vis));
40         cnt = 0;
41         dfs(1, 1);
42         memset(deg, 0, sizeof (deg));
43         for (i = 1; i <= n; ++i) {
44             for (j = 0; j < g[i].size(); ++j)
45                 if (low[i] != low[g[i][j]])
46                     deg[low[i]]++;
47         }
48         for (ans = i = 0; i <= n; ++i)
49             if (deg[i] == 1) ++ans;
50         printf("%d\n", (ans + 1) / 2);
51     }
52     return 0;
53 }

晓天_xiaotian 2010-10-06 14:22 发表评论

晓天_xiaotian 2010-10-05 16:18 发表评论

晓天_xiaotian 2010-10-04 16:14 发表评论

 1 /* 
 2  * File:   Timus 1742. Team building
 3  * Author: xiaotian @ hnu
 4  * Created on 2010年10月4日, 下午2:54
 5  * 题解：
 6  */
 7 #include <iostream>
 8 #include <string>
 9 #include <set>
10 #include <map>
11 #include <vector>
12 #include <algorithm>
13 using namespace std;
14 const int N = 100008;
15 
16 int deg[N];
17 int nxt[N];
18 int vised[N], cnt, beg;
19 
20 int dfs(int a) {
21     if (vised[a])
22         if (vised[a] >= beg) return vised[a] + 1 - beg;
23         else return cnt - beg;
24     vised[a] = cnt++;
25     return dfs(nxt[a]);
26 }
27 
28 int main() {
29     int n;
30     while (scanf("%d", &n) != EOF) {
31         cnt = 1;
32         memset(deg, 0, sizeof (deg));
33         for (int i = 0; i < n; i++) {
34             scanf("%d", nxt + i);
35             nxt[i]--;
36             deg[nxt[i]]++;
37         }
38         int maxR = 0, minR = 0;
39         for (int i = 0; i < n; i++, cnt++)
40             if (!deg[i]) {
41                 beg = cnt;
42                 minR++;
43                 maxR += dfs(i);
44             }
45         for (int i = 0; i < n; i++)
46             if (!vised[i]) {
47                 minR++, maxR++;
48                 int p = i;
49                 while (!vised[p]) {
50                     vised[p] = 1;
51                     p = nxt[p];
52                 }
53             }
54         printf("%d %d\n",minR,maxR);
55         break;
56     }
57     return 0;
58 }

晓天_xiaotian 2010-10-04 15:55 发表评论

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<queue>
 4 #include<math.h>
 5 #include<algorithm>
 6 using namespace std;
 7 #define N 408
 8 #define inf 0x3fffffff
 9 int n, m, ne;
10 double low, hig;
11 int vis[2 * N], num[2 * N];
12 double d[2 * N];
13 
14 struct node {
15     int adj;
16     double w;
17     node *next;
18 } *head[2 * N], g[2 * N * N];
19 
20 void addedge(int x, int y, double w) {
21     g[ne].adj = y;
22     g[ne].w = w;
23     g[ne].next = head[x];
24     head[x] = &g[ne];
25     ne++;
26 }
27 
28 void build() {
29     memset(head, 0, sizeof (head));
30     ne = 0;
31     double a = log(hig);
32     double b = log(low);
33     for (int i = 0; i < n; i++)
34         for (int j = 0; j < m; j++) {
35             double c;
36             scanf("%lf", &c);
37             c = log(c);
38             addedge(i + 1, j + n + 1, a - c);
39             addedge(j + n + 1, i + 1, c - b);
40         }
41 }
42 
43 int solve() {
44     int i;
45     queue<int> q;
46     for (i = 1; i <= n; i++) {
47         q.push(i);
48         d[i] = inf;
49         vis[i] = 1;
50         num[i] = 0;
51     }
52     while (!q.empty()) {
53         int x = q.front();
54         q.pop();
55         vis[x] = 0;
56         for (node *p = head[x]; p; p = p->next)
57             if (d[p->adj] > d[x] + p->w) {
58                 d[p->adj] = d[x] + p->w;
59                 if (!vis[p->adj]) {
60                     vis[p->adj] = 1;
61                     num[p->adj]++;
62                     if (num[p->adj] >= (int) sqrt(1.0 * n)) return 0;
63                     q.push(p->adj);
64                 }
65             }
66     }
67     return 1;
68 }
69 
70 int main() {
71     while (scanf("%d %d %lf %lf", &n, &m, &low, &hig) != EOF) {
72         build();
73         n += m;
74         int ans = solve();
75         puts(ans ? "YES" : "NO");
76     }
77     return 0;
78 }

 1 #include<iostream>
 2 #include<cmath>
 3 #include<queue>
 4 #define N 810
 5 #define E 320010
 6 using namespace std;
 7 
 8 bool vis[N];
 9 int cnt[N];
10 double dis[N];
11 int head[N];
12 int V[E], next[E];
13 double W[E];
14 int ne, n, m;
15 
16 void addedge(int u, int v, double w) {
17     V[ne] = v;
18     W[ne] = w;
19     next[ne] = head[u];
20     head[u] = ne++;
21 }
22 
23 void build(double l, double r) {
24     ne = 0;
25     l = log(l);
26     r = log(r);
27     memset(head, -1, sizeof (head));
28     for (int i = 0; i < n; i++)
29         for (int j = 0; j < m; j++) {
30             int a;
31             scanf("%d", &a);
32             double c = log(a);
33             addedge(j + n, i, r - c);
34             addedge(i, j + n, c - l);
35         }
36     n += m;
37 }
38 
39 bool spfa() {
40     int i;
41     queue<int>q;
42     for (i = 0; i < n; i++) {
43         vis[i] = true;
44         dis[i] = 10000000;
45         q.push(i);
46         cnt[i] = 0;
47     }
48     dis[0] = 0;
49     while (!q.empty()) {
50         int u = q.front();
51         q.pop();
52         vis[u] = 0;
53         for (int e = head[u]; e != -1; e = next[e]) {
54             if (dis[u] + W[e] < dis[V[e]]) {
55                 dis[V[e]] = dis[u] + W[e];
56                 if (!vis[V[e]]) {
57                     q.push(V[e]);
58                     vis[V[e]] = 1;
59                     if (++cnt[V[e]] > (int) sqrt(1.0 * n))
60                         return 0;
61                 }
62             }
63         }
64     }
65     return 1;
66 }
67 
68 int main() {
69     double l, r;
70     while (scanf("%d%d%lf%lf", &n, &m, &l, &r) != EOF) {
71         build(l, r);
72         puts(spfa() ? "YES" : "NO");
73     }
74     return 0;
75 }

晓天_xiaotian 2010-10-01 14:38 发表评论

 1 #include<iostream>
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<queue>
 5 using namespace std;
 6 int p[40500], a[40500][2], sum[40500], n, m;
 7 
 8 int find(int x) {
 9     if (p[x] != x)p[x] = find(p[x]);
10     return p[x];
11 }
12 
13 int judge(int x, int y) {
14     return find(x) == find(y);
15 }
16 
17 void make(int side) {
18     int ul, ur, dl, dr;
19     char c;
20     for (int i = 0; i < n; i++)
21     {
22         for (int j = 0; j <= m; j++) {
23             scanf("%c", &c);
24             if (j == m) break;
25             ul = i * (m + 1) + j;
26             ur = ul + 1;
27             dl = (i + 1)*(m + 1) + j;
28             dr = dl + 1;
29             if ((c == 'X') || (c == '\\')) {
30                 a[ul][side]++;
31                 a[dr][side]++;
32                 if (!judge(ul, dr))p[p[ul]] = p[dr];
33             }
34             if ((c == 'X') || (c == '/')) {
35                 a[ur][side]++;
36                 a[dl][side]++;
37                 if (!judge(ur, dl))p[p[ur]] = p[dl];
38             }
39         }
40     }
41 }
42 
43 int main() {
44     while (scanf("%d%d\n", &n, &m) != EOF) {
45         int i, ans = 0;
46         for (i = 0; i < (m + 1)*(n + 1); i++) p[i] = i;
47         make(0);
48         make(1);
49         for (i = 0; i < (m + 1)*(n + 1); i++)
50             if (a[i][0] || a[i][1]) sum[find(i)] += abs(a[i][0] - a[i][1]);
51         for (i = 0; i < (m + 1)*(n + 1); i++)
52             if ((a[i][0] || a[i][1]) && (p[i] == i)) ans += sum[i] ? sum[i] / 2 : 1;
53         printf("%d\n", ans);
54         return 0;
55     }
56 }

晓天_xiaotian 2010-09-30 12:06 发表评论

 1 #include<stdio.h>
 2 #include<iostream>
 3 #include<string.h>
 4 #include<queue>
 5 #include<vector>
 6 #define N 108
 7 #define inf 0x3ffffff
 8 using namespace std;
 9 vector<int>g[N];
10 int clor[N];
11 int n;
12 int bfs(int s)
13 {
14     queue<int>q;
15     q.push(s);
16     clor[s]=0;
17     while(!q.empty())
18     {
19         int p=q.front(); q.pop();
20         for(int i=0;i<g[p].size();i++)
21         {
22             if(clor[g[p][i]]==-1)
23             {
24                 clor[g[p][i]]=1-clor[p];
25                 q.push(g[p][i]);
26             }
27             else if(clor[g[p][i]]!=1-clor[p]) return 0;
28         }
29     }
30     return 1;
31 }
32     
33 int main()
34 {
35     while(scanf("%d",&n)!=EOF)
36     {
37         for(int i=0;i<=n;i++) g[i].clear();
38         for(int i=0;i<n;i++)
39         {
40             int k;
41             while(scanf("%d",&k),k)
42             {
43                 g[i].push_back(k-1);
44                 g[k-1].push_back(i);
45             }
46         }
47         memset(clor,-1,sizeof(clor));
48         int i;
49         for(i=0;i<n;i++)
50         if(clor[i]==-1) if(bfs(i)==0) break;
51         if(i<n) puts("-1");
52         else for(int i=0;i<n;i++)printf(i==n-1?"%d\n":"%d",clor[i]);
53     }
54     return 0;
55 }

晓天_xiaotian 2010-09-29 20:26 发表评论

 1 /* 
 2  * File:   1022. Genealogical tree
 3  * Author: xiaotian @ hnu
 4  * Created on 2010年9月28日, 下午 9:26
 5  * 解题：很裸的拓扑排序 
 6  */
 7  
 8 #include<stdio.h>
 9 #include<iostream>
10 #include<string.h>
11 #define N 108
12 using namespace std;
13 bool t[N][N];
14 int d[N];
15 int n;
16 void init()
17 {
18     memset(d,0,sizeof(d));
19     memset(t,0,sizeof(t));
20     for(int i=1;i<=n;i++)
21     for(int a;scanf("%d",&a) && (a>0);d[a]++)
22     t[i][a]=1;
23 }
24 void calc()
25 {
26     for(int dex=1;dex<=n;dex++)
27     {
28         int k=1;
29         for(;(k<=n)&&(d[k]>0);k++);
30         d[k]=1<<30-1;
31         for(int i=1;i<=n;i++) if(t[k][i]) d[i]--;
32         printf(dex==n?"%d\n":"%d ",k);
33     }
34 }
35 int main()
36 {
37     while(scanf("%d",&n)!=EOF)
38     {
39         init();
40         calc();
41     }
42     return 0;
43 }

晓天_xiaotian 2010-09-29 10:08 发表评论