poj-2531

// 3916K    375MS   G++
#include <cstdio>  
#include <queue>  
  
using namespace std;  
  
#define MAX 22  
  
int NodeBitId[MAX];  
  
int G[MAX][MAX];  
  
#define INF 99999;  
  
long MAXT;  
  
void initNodeBitId() {  
    int val = 0x1;  
    for (int i = 1; i <= MAX; i++) {  
        // printf("%d\n", val);  
        NodeBitId[i] = val;  
        val <<= 1;  
    }  
}  
  
struct BFSNode {  
    int chooseNum;  
    long T;  
    int choosedMap;  
};  
  
int NodeNum;
#define MAX2 1030*1030

queue<BFSNode> BFSQueue;

char BFSFlag[MAX2];

int BFS() {
    while(BFSQueue.size()) {
        BFSQueue.pop();
    }
    MAXT = -INF;
    BFSNode beginNode;
    beginNode.chooseNum = 0;
    beginNode.T = 0;
    beginNode.choosedMap = 0;
    BFSFlag[0] = 1;
    BFSQueue.push(beginNode);

    int mask = 0xffffffff>>(32 - NodeNum);

    while(BFSQueue.size()) {
        BFSNode curNode = BFSQueue.front();
        BFSQueue.pop();
        long curT = curNode.T;
        // printf("%ld\n", curT);
        MAXT = MAXT > curT ? MAXT : curT;
        int curChooseNum = curNode.chooseNum;
        int curChoosedMap = curNode.choosedMap;

        for (int i = 1; i <= NodeNum; i++) {
            // printf("%d %d\n", NodeBitId[i], curChoosedMap);
           if (! (NodeBitId[i]&curChoosedMap)) { // if node i is not choosed yet
                int newChoosedMap = curChoosedMap|NodeBitId[i];
                int reverseChoosedMap = (~newChoosedMap)&mask;
                if (!BFSFlag[newChoosedMap] && !BFSFlag[reverseChoosedMap]) {
                    BFSFlag[newChoosedMap] = 1;
                    BFSFlag[reverseChoosedMap] = 1;
                    BFSNode newNode;
                    newNode.chooseNum = curChooseNum + 1;
                    newNode.choosedMap = newChoosedMap;
                    long newT = curT;
                    for (int j = 1; j <= NodeNum; j++) {
                       if (! (NodeBitId[j]&curChoosedMap)) { // if node j is not choosed
                            newT += G[j][i];
                       } else { // if j has been choosed
                            newT -= G[j][i];
                       }
                    }
                    newNode.T = newT;
                    BFSQueue.push(newNode);
                }
           } 
        }

    }

}

void solve() {
    BFS();
    printf("%ld", MAXT);
}

int main() {  
    initNodeBitId();  
    while(scanf("%d", &NodeNum) != EOF) {  
        for (int i = 1; i <= NodeNum; i++) {
           for (int j = 1; j <= NodeNum; j++) {
               scanf("%d", &G[i][j]);
           } 
        }
        solve();
    }  
}  

最初看这道题还想着用流或者带权二分图解决，后来想不出怎么解，就老老实实的用BFS解了, 后来看有人用 无向完全图的最大割问题 解决的，不过貌似时间也差不多。

BFS解的步骤，就是每次在已经选择的node中，增加一个新的node，然后看增加以后，traffic T是否更大，如果变大，就更新T，最后遍历完所有的组合以后，输出T就可以。

这道题是纯遍历每个节点（以前的很多BFS是有结束条件的），每个节点对应这一种选取方案，而因为节点数量最多有20个，

因此，用一个int作为bitmap保存此BFS node的选取方案完全足够，不过要事先搞一个数组对应此bitmap中的每一位，即每一个node：

0x1, 0x2, 0x4.... 直到第20位。

BFS的起始node对应的选取方案是一个都不选取到subnetwork1, 然后在此node（选取方案）基础上，可以选取一个新的node，这个新的node可以从已有的node中任意选取，

如果有20个node， 那么就有20种选择，及此BFSNode 可以达到 20个BFSNode（选取一个node的方案）中，

然后重复上面的BFS过程，每次遍历到一个node时， 根据当前node的选取方案看还有哪些node可以选取，将其添加到BFSQueue中，每次新加一个node，根据当前BFSNode的选取方案的得到新的选取方案的traffic T（比如，本次选取了node j，对于已经选取的node i，T -= G[i][j] ， 从i到j的流不再算到T中， 对与没有选取的node k， T+= G[j][k], 从j到k的流算到T里了）， 同时根据当前方案的chooseBitmap 生成新的方案的chooseBitmap（只需将相应的位 置1 即可），同时看T是否有新的最大值，如果有，更新之。

一个优化就是：选择方案是互逆对等的，比如有3个node， 那么将 node 1选入 subnetwork1 和 将node2，3选入subnetwork1， T是一样的，因此，在BFS遍历时，

也可以将此条件考虑进去，一旦 方案X被遍历过了，那么方案X的逆方案也可以认为遍历过了。这样就大大减少了遍历次数。

就是占的内存有点多，一个BFSFlag就需要 1024*1024的char，其实用bit完全够了。