HDU 4467 Graph（图论+暴力）（2012 Asia Chengdu Regional Contest）

Description

P. T. Tigris is a student currently studying graph theory. One day, when he was studying hard, GS appeared around the corner shyly and came up with a problem: 
Given a graph with n nodes and m undirected weighted edges, every node having one of two colors, namely black (denoted as 0) and white (denoted as 1), you’re to maintain q operations of either kind: 
* Change x: Change the color of x ^th node. A black node should be changed into white one and vice versa. 
* Asksum A B: Find the sum of weight of those edges whose two end points are in color A and B respectively. A and B can be either 0 or 1. 
P. T. Tigris doesn’t know how to solve this problem, so he turns to you for help.

 

Input

There are several test cases. 
For each test case, the first line contains two integers, n and m (1 ≤ n,m ≤ 10 ⁵), where n is the number of nodes and m is the number of edges. 
The second line consists of n integers, the i ^th of which represents the color of the i ^th node: 0 for black and 1 for white. 
The following m lines represent edges. Each line has three integer u, v and w, indicating there is an edge of weight w (1 ≤ w ≤ 2 ³¹ - 1) between u and v (u != v). 
The next line contains only one integer q (1 ≤ q ≤ 10 ⁵), the number of operations. 
Each of the following q lines describes an operation mentioned before. 
Input is terminated by EOF.

 

Output

For each test case, output several lines. 
The first line contains “Case X:”, where X is the test case number (starting from 1). 
And then, for each “Asksum” query, output one line containing the desired answer.

 

题目大意：给n个点m条无向边，每个点有一个颜色（0 or 1），每条边有一个权值。有q个询问，或翻转某个结点的颜色，或询问一个点的颜色为x、另一个点的颜色为y的边的权和。

思路：直接暴力复杂度高达O(qm)，完全无法承受。好像没有其他方法，我们只能暴力地优美一点。

用一个sum[]记录答案，询问的时候O(1)输出。

记deg[u]为结点u的度，对于所有deg[v]＜deg[u]，连一条边v→u。

state[u]记录对于所有deg[v]＜deg[u]的v↔u的权值和。

当修改u的时候，对于所有deg[v]＜deg[u]，利用state直接修改。对于deg[v]≥deg[u]，一个一个修改。

对于一个无重边的图来讲，对每个点来说，所有度数大于等于它的点不超过$ O(\sqrt{m}) $个（因为若一个点的度数为$k$，那么度数大于等于它的点最多$x \leq k$个，这些点的度数总和至少是$k^2$，由于$k^2<=2 \times m$，所以$O(x)=O(\sqrt m)$）

那么时间复杂度为$O(q \times \sqrt m )$

这题要去重边（权和相加）。不去重边，2个点10W条边你还得死……

 

代码（3187MS）：

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 using namespace std;
 typedef long long LL;

 const int MAXN = ;
 const int MAXE = ;

 struct Edge {
     int from, to, del;
     LL w;
     void read() {
         scanf("%d%d%I64d", &from, &to, &w);
         del = ;
         if(from > to) swap(from, to);
     }
     bool operator < (const Edge &rhs) const {
         if(from != rhs.from) return from < rhs.from;
         return to < rhs.to;
     }
     bool operator == (const Edge &rhs) const {
         return from == rhs.from && to == rhs.to;
     }
 } edge[MAXE];

 LL sum[];
 int n, m, q;
 int head[MAXN], deg[MAXN], ecnt;
 int col[MAXN];
 LL state[MAXN][];
 int to[MAXE], next[MAXE], dir[MAXE];
 LL weight[MAXE];

 void init() {
     memset(head, , sizeof(head));
     memset(sum, , sizeof(sum));
     memset(deg, , sizeof(deg));
     memset(state, , sizeof(state));
     ecnt = ;
 }

 void add_edge(int u, int v, LL w, bool flag) {
     to[ecnt] = v; weight[ecnt] = w; dir[ecnt] = flag; next[ecnt] = head[u]; head[u] = ecnt++;
 }

 void change() {
     int x, c;
     scanf("%d", &x);
     c = col[x]; col[x] = !col[x];
     sum[c] -= state[x][];
     sum[c + ] -= state[x][];
     sum[col[x]] += state[x][];
     sum[col[x] + ] += state[x][];
     for(int p = head[x]; p; p = next[p]) {
         int &v = to[p];
         if(!dir[p]) {
             state[v][c] -= weight[p];
             state[v][col[x]] += weight[p];
         }
         sum[c + col[v]] -= weight[p];
         sum[col[x] + col[v]] += weight[p];
     }
 }

 char s[];

 int main() {
     int t = ;
     while(scanf("%d%d", &n, &m) != EOF) {
         init();
         for(int i = ; i <= n; ++i) scanf("%d", &col[i]);
         for(int i = ; i <= m; ++i) {
             edge[i].read();
             sum[col[edge[i].from] + col[edge[i].to]] += edge[i].w;
         }
         printf("Case %d:\n", ++t);
         sort(edge + , edge + m + );
         for(int i = ; i < m; ++i) {
             if(edge[i] == edge[i + ]) {
                 edge[i].del = true;
                 edge[i + ].w += edge[i].w;
             } else {
                 ++deg[edge[i].from], ++deg[edge[i].to];
             }
         }
         for(int i = ; i <= m; ++i) {
             if(edge[i].del) continue;
             if(deg[edge[i].from] < deg[edge[i].to]) {
                 add_edge(edge[i].from, edge[i].to, edge[i].w, );
                 state[edge[i].to][col[edge[i].from]] += edge[i].w;
             } else if(deg[edge[i].from] > deg[edge[i].to]) {
                 add_edge(edge[i].to, edge[i].from, edge[i].w, );
                 state[edge[i].from][col[edge[i].to]] += edge[i].w;
             } else {
                 add_edge(edge[i].from, edge[i].to, edge[i].w, );
                 add_edge(edge[i].to, edge[i].from, edge[i].w, );
             }
         }
         scanf("%d", &q);
         while(q--) {
             scanf("%s", s);
             if(*s == 'A') {
                 int x, y;
                 scanf("%d%d", &x, &y);
                 printf("%I64d\n", sum[x + y]);
             } else change();
         }
     }
 }

代码（3078MS）（稍微改了一下）：

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 using namespace std;
 typedef long long LL;

 const int MAXN = ;
 const int MAXE = ;

 struct Edge {
     int from, to, del;
     LL w;
     void read() {
         scanf("%d%d%I64d", &from, &to, &w);
         del = ;
         if(from > to) swap(from, to);
     }
     bool operator < (const Edge &rhs) const {
         if(from != rhs.from) return from < rhs.from;
         return to < rhs.to;
     }
     bool operator == (const Edge &rhs) const {
         return from == rhs.from && to == rhs.to;
     }
 } edge[MAXE];

 LL sum[];
 int n, m, q;
 int head[MAXN], deg[MAXN], ecnt;
 int col[MAXN];
 LL state[MAXN][];
 int to[MAXE], next[MAXE];
 LL weight[MAXE];

 void init() {
     memset(head, , sizeof(head));
     memset(sum, , sizeof(sum));
     memset(deg, , sizeof(deg));
     memset(state, , sizeof(state));
     ecnt = ;
 }

 void add_edge(int u, int v, LL w) {
     to[ecnt] = v; weight[ecnt] = w; next[ecnt] = head[u]; head[u] = ecnt++;
 }

 void change() {
     int x, c;
     scanf("%d", &x);
     c = col[x]; col[x] = !col[x];
     sum[c] -= state[x][];
     sum[c + ] -= state[x][];
     sum[col[x]] += state[x][];
     sum[col[x] + ] += state[x][];
     for(int p = head[x]; p; p = next[p]) {
         int &v = to[p];
         state[v][c] -= weight[p];
         state[v][col[x]] += weight[p];
         sum[c + col[v]] -= weight[p];
         sum[col[x] + col[v]] += weight[p];
     }
 }

 char s[];

 int main() {
     int t = ;
     while(scanf("%d%d", &n, &m) != EOF) {
         init();
         for(int i = ; i <= n; ++i) scanf("%d", &col[i]);
         for(int i = ; i <= m; ++i) {
             edge[i].read();
             sum[col[edge[i].from] + col[edge[i].to]] += edge[i].w;
         }
         printf("Case %d:\n", ++t);
         sort(edge + , edge + m + );
         for(int i = ; i < m; ++i) {
             if(edge[i] == edge[i + ]) {
                 edge[i].del = true;
                 edge[i + ].w += edge[i].w;
             } else {
                 ++deg[edge[i].from], ++deg[edge[i].to];
             }
         }
         for(int i = ; i <= m; ++i) {
             if(edge[i].del) continue;
             if(deg[edge[i].from] < deg[edge[i].to]) {
                 add_edge(edge[i].from, edge[i].to, edge[i].w);
                 state[edge[i].to][col[edge[i].from]] += edge[i].w;
             } else {
                 add_edge(edge[i].to, edge[i].from, edge[i].w);
                 state[edge[i].from][col[edge[i].to]] += edge[i].w;
             }
         }
         scanf("%d", &q);
         while(q--) {
             scanf("%s", s);
             if(*s == 'A') {
                 int x, y;
                 scanf("%d%d", &x, &y);
                 printf("%I64d\n", sum[x + y]);
             } else change();
         }
     }
 }