最初的思路
看到这道题我是很懵的，就是让我自己手算，我也不知道该怎么算。于是我测试，打补丁，再测试……最后竟然AC了，补丁整理了一下，也没有特别难看。
基本思路是：
- 从题中读入新的持股信息，这时候多了 parent -> child 的持股，因此 parent 的父亲可能可以通过 parent 进而控制 child，需要检查 parent 的各个父亲对 child是否有控制。
- 如果读入的 parent 还控制了 child，那么还有一种情况，parent 可能通过 child 还控制了 child 的孩子。（现在看来，好像应该只要是 child 对其有持股的（而不必是 child 控制的），都可能出现 parent -> child -> i 的情况，但我也不知道为什么我只考虑了控制关系就AC了O__O "…可能是所有的 test 都凑巧？还是在更深层的关系上等价？）
- 检查的时候，如果有新的控制关系成立，就继续检查上述这两种情况，直到一片寂静。
代码：
/*
ID: ufoshen1
LANG: C++
TASK: concom
*/
#include <cstdio>
#include <cstdlib>
const int maxN = 100;
int N; //目前的公司数
int queue[1000000][2], start, end; //存放待检查的control关系
int percent[maxN + 1][maxN + 1];
bool control[maxN + 1][maxN + 1];
bool update(int parent, int child){
//更新父子关系，有更新发生则返回true
int perc = percent[parent][child];
for(int i = 1; i <= N; i ++){
if(control[parent][i]){
perc += percent[i][child];
}
}
if(perc > 50 && !control[parent][child]) return control[parent][child] = true;
return false;
}
void checkParent(int parent, int child){
//i->parent->child的情况加入待检查的队列
for(int i = 1; i <= N; i ++){
if(control[i][parent] && !control[i][child]){
queue[end][0] = i;
queue[end ++][1] = child;
}
}
}
void checkChild(int parent, int child){
//parent->child->i的情况加入待检查队列
for(int i = 1; i <= N; i ++){
if(control[child][i] && !control[parent][i]){
queue[end][0] = parent;
queue[end ++][1] = i;
}
}
}
int main(){
FILE *fin = fopen("concom.in", "r");
FILE *fout = fopen("concom.out", "w");
int n, parent, child, perc;
fscanf(fin, "%d", &n);
for(int i = 0; i < n; i ++){
fscanf(fin, "%d %d %d", &parent, &child, &perc);
if(parent > N) N = parent;
if(child > N) N = child;
start = 0; end = 0;
percent[parent][child] = perc;
//parent对child增加了持有比例，就可能有i->parent->child
checkParent(parent, child);
if(perc > 50){
control[parent][child] = true;
//parent控制child，还可能有parent->child->i
checkChild(parent, child);
}
while(end > start){
int newParent = queue[start][0], newChild = queue[start][1];
start ++;
if(update(newParent, newChild)){
//newParent新控制了newChild，可能有parent->child->i 和 i->parent->child
checkParent(newParent, newChild);
checkChild(newParent, newChild);
}
}
}
for(int i = 1; i <= N; i ++){
for(int j = 1; j <= N; j ++){
if(control[i][j] && i != j) fprintf(fout, "%d %d\n", i, j);
}
}
return 0;
}
执行情况：
Compiling...
Compile: OK
Executing...
Test 1: TEST OK [0.000 secs, 12036 KB]
Test 2: TEST OK [0.000 secs, 12036 KB]
Test 3: TEST OK [0.000 secs, 12036 KB]
Test 4: TEST OK [0.000 secs, 12036 KB]
Test 5: TEST OK [0.000 secs, 12036 KB]
Test 6: TEST OK [0.000 secs, 12036 KB]
Test 7: TEST OK [0.000 secs, 12036 KB]
Test 8: TEST OK [0.000 secs, 12036 KB]
Test 9: TEST OK [0.126 secs, 12036 KB]
All tests OK.
Your program ('concom') produced all correct answers! This is your
submission #10 for this problem. Congratulations!
暴搜
智商抱歉，从上午看到下午，还是没有看懂标答问什么是对的。我尝试着按照标答的思路自己写了一遍，尽管在我看来和标答没有任何实质性的差别，却还是在第 9 道题WA了。
后来终于有一个答案很快就看懂了：暴搜。在把直接占有的百分比都读入后，对所有的 i，j，检查是否有 i 控制 j。如果这一轮有增加任何新的控制关系，就再搜一轮，直到搜到没有产生新的关系为止。代码简直一遍就 bug-free 好不好!
复杂度：如果有 100 个公司，每一轮暴搜将有 100 ^ 3次操作，就算搜上一百次，也还是可以忍受的。nocow 上这位同学说最后一个点 0.248s，我写出来甚至还快了很多……
代码：
#include <cstdio>
#include <cstdlib>
const int maxN = 100;
int N; //目前的公司数
int percent[maxN + 1][maxN + 1];
bool control[maxN + 1][maxN + 1];
int main(){
FILE *fin = fopen("concom.in", "r");
FILE *fout = fopen("concom.out", "w");
int n, parent, child, perc, flag = 1, total;
for(int i = 0; i <= maxN; i ++) control[i][i] = true; //题目说自己控制自己
fscanf(fin, "%d", &n);
for(int i = 0; i < n; i ++){
fscanf(fin, "%d %d %d", &parent, &child, &perc);
if(parent > N) N = parent;
if(child > N) N = child;
percent[parent][child] = perc;
if(perc > 50) control[parent][child] = true; //直接控股大于50%就控制了
}
while(flag){
flag = 0; //这一轮有没有新增控制关系
for(int i = 1; i <= N; i ++){
for(int j = 1; j <= N; j ++){ //检查i是否控制j
if(control[i][j]) continue; //本来就控制，跳过
total = 0;
for(int k = 1; k <= N; k ++){
if(control[i][k]) total += percent[k][j];
}
if(total > 50){
control[i][j] = 1;
flag = 1;
}
}
}
}
for(int i = 1; i <= N; i ++){
for(int j = 1; j <= N; j ++){
if(control[i][j] && i != j) fprintf(fout, "%d %d\n", i, j);
}
}
return 0;
}
效果：
Compiling...
Compile: OK
Executing...
Test 1: TEST OK [0.000 secs, 4224 KB]
Test 2: TEST OK [0.000 secs, 4224 KB]
Test 3: TEST OK [0.000 secs, 4224 KB]
Test 4: TEST OK [0.000 secs, 4224 KB]
Test 5: TEST OK [0.000 secs, 4224 KB]
Test 6: TEST OK [0.000 secs, 4224 KB]
Test 7: TEST OK [0.000 secs, 4224 KB]
Test 8: TEST OK [0.014 secs, 4224 KB]
Test 9: TEST OK [0.070 secs, 4224 KB]
All tests OK.
Your program ('concom') produced all correct answers! This is your
submission #21 for this problem. Congratulations!
dfs
在把直接占有的百分比都读入后，对每对控制的公司 i，j ，都做一下 dfs。我也只是大概理解的样子……
已知 i 控制了 j，那么会造成的结果是，i 通过控制 j，也可以加上 j 控持有的 k 的股份。（至于另一方面，原先控制 i 的公司会控制 j，这个不在考虑范围内，等到搜索到“控制 i 的公司控制了 i ”的时候自然会考虑的。）
如果原先 i 对 k 持有的股份就大于 50 了， 那就是循环 i, k 层考虑的事了。而且反正已经大于一半了，这里也不用再加了。如果 i 对 k 持有的股份在刚才加法之后超过了 50，那 i 控制 k 还是刚刚知道的，就继续搜下去呀。
好像如果用一个数组，应该会出现重复加的问题，就用两个数组存直接控股和直接+间接的复杂控股。
代码几乎也是仿照 nocow 上某同学的答案写的：
#include <cstdio>
#include <cstdlib>
#include <cstring>
const int maxN = 100;
int N; //目前的公司数
int percent[maxN + 1][maxN + 1];
int cplxPercent[maxN + 1][maxN + 1];
void dfs(int i, int j){
for(int k = 1; k <= N; k ++){
if(cplxPercent[i][k] <= 50 && k != i){
//i -> j -> k
cplxPercent[i][k] += percent[j][k];
if(cplxPercent[i][k] > 50) dfs(i, k);
}
}
}
int main(){
FILE *fin = fopen("concom.in", "r");
FILE *fout = fopen("concom.out", "w");
int n, parent, child, perc, flag = 1, total;
fscanf(fin, "%d", &n);
for(int i = 0; i < n; i ++){
fscanf(fin, "%d %d %d", &parent, &child, &perc);
if(parent > N) N = parent;
if(child > N) N = child;
percent[parent][child] = perc;
}
memcpy(cplxPercent, percent, sizeof(percent));
for(int i = 1; i <= N; i ++){
for(int j = 1; j <= N; j ++){
if(cplxPercent[i][j] > 50) dfs(i, j);
}
}
for(int i = 1; i <= N; i ++){
for(int j = 1; j <= N; j ++){
if(cplxPercent[i][j] > 50 && i != j) fprintf(fout, "%d %d\n", i, j);
}
}
return 0;
}
啊终于过了，还是比暴搜要快的，最后一个点 0.014secs。
