POJ 3592 缩点加spfa

缩点的最大好处在于把一个杂乱无章的有向图变成一个有向无环图， 而在有向无环图中，有两种点比较特殊：一种是入度为 0 的点，另一种是 出度为 0 的点。我们把入度为0的点就叫做根，出度为0的点叫做叶子！

题意：一辆坦克从N*M矩阵的左上角出发，每次往右或往下走一格，每格可以是’#’(表示不可以走)，’*’表示传送门，或者是数字，表示在该格可以获得的值（只能取一次），传送门可以将到达该处的坦克传送到指定位置，你可以选择被传送或者走相邻的格，问坦克可以获得的值的和最大为多少。

分析：题目是说最终能获得的最大值，并没有指定最终要到达的位置；

因为传送门的存在，可能出现环；

算法：邻接表建立有向图；

求原图的强连通分量，缩点后重建有向图；

对重建后的有向图，利用bfs求从原图左上角点(0,0)出发的最长路(没有指定终点)

这题是盗用的人家的代码，写的风格蛮不错的，把输入，targan缩点，重新建图，bfs写的都是蛮清楚的，其中建边的时候对’*’的处理蛮可以的，先读入图，再根据”进行坐标的读入，将二维坐标转化为一维，还要注意坑就是直接跳转的地方有可能是#！！！！

#include <iostream>
#include <vector>
#include <queue>
#include <stack>
using namespace std;

const int MAX_EDGE_NUM = 50000 + 10;
const int MAX_POINT_NUM = 2200 + 10;

// 假设对边u-->v：v是被指向的点，next是从u出发的下一条边的编号
struct EDGE
{
int v;
int next;
};

// 数组g和数组adj联合使用构造有向图(第一次建图)
EDGE g[MAX_EDGE_NUM];
int adj[MAX_POINT_NUM];

// 第二次建图使用vector
vector<int> vec[MAX_POINT_NUM];

int low[MAX_POINT_NUM];         // low[u]：是u或u的子树能追溯到的最早的栈中的节点的次序号
int dfn[MAX_POINT_NUM];         // dfn[u]：节点u搜索的次序编号(时间戳)
int sccf[MAX_POINT_NUM];        // sccf[i]：第i个点所在的强连通分量的编号
int dis[MAX_POINT_NUM];         // dis[i]：从点0到达点i所能获得的最大值
int ores[MAX_POINT_NUM];        // ores[i]：在点i能获得的值
int sum[MAX_POINT_NUM];         // 强连通分量i的煤矿总量
bool ins[MAX_POINT_NUM];        // 是否在栈中
bool inq[MAX_POINT_NUM];        // 是否在队中
int scc;                        // 强连通分量的个数
int e, index;                   // 全局临时变量
int n, m;                       // 点数  边数
stack<int> s;

void addEdge(int u, int v)
{
g[e].v = v;
g[e].next = adj[u];
adj[u] = e;
e++;
}

void Init()
{
for (int i=1; i<=scc; ++i)
{
vec[i].clear();
}
e = scc = 0;
index = 1;
memset(adj, -1, sizeof(adj));
memset(low, 0, sizeof(low));
memset(dfn, 0, sizeof(dfn));
memset(ins, false, sizeof(ins));
memset(ores, 0, sizeof(ores));
memset(sum, 0, sizeof(sum));
}

void RebuildMap()
{
// 枚举每一个点u
for (int u=0; u<n*m; ++u)
{
// 对每一条原始边 u-->v
for (int k=adj[u]; k!=-1; k=g[k].next)
{
int v = g[k].v;
// 新边 sccf[u]-->sccf[v]
if (sccf[u] != sccf[v])
{
vec[sccf[u]].push_back(sccf[v]);
}
}
}
}

void Tarjan(int u)
{
int v;
low[u] = dfn[u] = index++;
s.push(u);
ins[u] = true;

// 枚举每一条边
for (int k=adj[u]; k!=-1; k=g[k].next)
{
v = g[k].v;
if (0 == dfn[v])
{
Tarjan(v);
if (low[v] < low[u])
{
low[u] = low[v];
}
}
else if (ins[v] && dfn[v]<low[u])
{
low[u] = dfn[v];
}
}
// 如果节点u是强连通分量的根
if (dfn[u] == low[u])
{
scc++;
do
{
v = s.top();
s.pop();
ins[v]= false;
sccf[v] = scc;
sum[scc] += ores[v];
}while (u != v);
}
}

// 从第一个点开始求最长路
void Bfs()
{
memset(inq, false, sizeof(inq));
memset(dis, 0, sizeof(dis));

queue<int> q;
q.push(sccf[0]);
inq[sccf[0]] = true;
dis[sccf[0]] = sum[sccf[0]];

while (!q.empty())
{
int u = q.front();
q.pop();
inq[u] = false;
// 对边u-->v
for (int i=0; i<vec[u].size(); ++i)
{
int v = vec[u][i];
if (dis[v] < dis[u]+sum[v])
{
dis[v] = dis[u] + sum[v];
if (!inq[v])
{
inq[v] = true;
q.push(v);
}
}
}
}
}

void Input()
{
char map[45][45];
int r, c, i, j;
// 输入原始图
scanf("%d%d", &n, &m);
for (i=0; i<n; ++i)
{
scanf("%s", map[i]);
}
// 建立有向图
for (i=0; i<n; ++i)
{
for (j=0; j<m; ++j)
{
if (map[i][j] != '#')
{
// 向下走
if (i+1<n && map[i+1][j]!='#')
{
addEdge(i*m+j, (i+1)*m+j);
}
// 向右走
if (j+1<m && map[i][j+1]!='#')
{
addEdge(i*m+j, i*m+j+1);
}
ores[i*m+j] = map[i][j] - '0';
if ('*' == map[i][j])
{
ores[i*m+j] = 0;
scanf("%d%d", &r, &c);
if ('#' != map[r][c])
{
addEdge(i*m+j, r*m+c);
}
}
}
}
}
}

int main()
{
int i, cases;
scanf("%d", &cases);
while (cases--)
{
// 数据初始化
Init();
// 输入数据并建立有向图
Input();
// 求强连通分量
for (i=0; i<n*m; ++i)
{
if (0 == dfn[i])
{
Tarjan(i);
}
}
// 求得强连通分量后进行缩点，对缩点后的图利用vector进行重建
RebuildMap();
// 求最长路
Bfs();
// 求得最终答案并输出：最长路
int ans = -1;
for (i=1; i<=scc; ++i)
{
if (dis[i] > ans)
{
ans = dis[i];
}
}
printf("%d\n", ans);
}
return 0;
}