poj 1511

题目概述

有P个地点，编号1到P，这些地点之间有Q条单向的乘车路线，每条路线从from到to，费用w，现在有P个人从1出发，每个人要前往一个地点签到，然后返回，求所有人往返路费和的最小值
所有地点之间强连通

时限

8000ms/24000ms

输入

第一行正整数times，其后times组数据，每组数据第一行两个正整数P,Q，其后Q行，每行三个正整数from,to,w

限制

1<=P,Q<=1e6

输出

每行一个数，为所求最小和

样例输入

2
2 2
1 2 13
2 1 33
4 6
1 2 10
2 1 60
1 3 20
3 4 10
2 4 5
4 1 50

样例输出

46
210

讨论

图论，单源最短路，bellman_ford队列优化算法，静态邻接表，静态队列，题目概述已经抽象好了，这类题以前也做过多次，将所有有向边都反向后重新构图再求一次单源最短路，就可以完成多起点单终点的最短路处理
实现方面，第一次遇到不能用vector开邻接表的情况，因为数据太大了，vector每当已满时再插入就会重新开一片两倍大的地方然后把原来的东西复制过来，外加一些杂七杂八的常数，能过，但是几乎是贴边过（7704ms），万般无奈，学习如何使用静态邻接表，这部分会在代码中注明
另外感觉队列似乎也有点慢，也顺手做成静态的了，类似于栈，这个很熟
其实额本来还想用getchar做一个读入函数，算了，不费那劲了
其实fread才是最快的，不过首先得知道oj读的哪个文件输入

题解状态

48152K，1969MS，C++，1543B

题解代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 1000003
#define memset0(a) memset(a,0,sizeof(a))

int index;//处理邻接表用的 放的位置有点太高了
struct Edge//边的结构
{
    int to, w, next;//to 边指向的点 weight 权重 这里指路费 next 邻接表用到的 指向相同起点的下一个节点的位置
    Edge() {}
    Edge(int to, int w, int next) :to(to), w(w), next(next) {}
};
int P, Q;//地点数 路的数量
Edge graph1[MAXN], graph2[MAXN];//邻接表 由于要跑两次最短路 所以需要两张图
int al1[MAXN], al2[MAXN];//adjacency_list 邻接表 其实是以下标为起点的邻接表的最后一个节点的下一节点的位置（是空的）
int q[MAXN * 2], front, back;//数组模拟队列 以及队头队尾 一倍竟然还不够放 
int dis1[MAXN], dis2[MAXN];//distance 最小权重 这个以前就有
bool inq[MAXN];//in_queue 节点已在队列中 这个以前也有
void bellman_ford(Edge *graph, int *dis, int *al)//最短路主体 由于要跑两趟而写成函数 三个参数不用解释了吧
{
    q[back++] = 1;//入队
    inq[1] = 1;
    dis[1] = 0;//到起点距离0
    while (front != back) {//如果队不空
        int a = q[front++], next = a;//出队 next是遍历邻接表用的
        inq[a] = 0;
        while (next != al[a]) {//上面说了 al数组最后一个数指向的节点都是空的 遇到一个空的节点就不处理了
            Edge *b = graph + next;//其实就是&graph[next] 只是试试这样能快点不
            if (dis[b->to] > dis[a] + b->w) {
                dis[b->to] = dis[a] + b->w;
                if (!inq[b->to]) {
                    q[back++] = b->to;
                    inq[b->to] = 1;
                }
            }
            next = b->next;//这行以前没有 不难理解 和链表相似 取得下一节点
        }
    }
}
long long fun()
{
    for (int p = 1; p <= P; p++)
        al1[p] = al2[p] = p;//首先为每个起点的第一个节点划定地方 总感觉这个操作可以优化
    index = P;//初始化index值
    for (int p = 1; p <= Q; p++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);//input
        index++;//先递增
        graph1[al1[a]] = Edge(b, w, index);//将al数组指向的空白区域填满 index是下一个节点的位置
        graph2[al2[b]] = Edge(a, w, index);//反向构图
        al1[a] = index;//现在index真的是下一个节点的位置了 也是空的（其实可能有上一次残留的数据）
        al2[b] = index;
    }
    for (int p = 1; p <= P; p++)
        dis1[p] = dis2[p] = INF;//初始化最小权值 这个没法优化
    bellman_ford(graph1, dis1, al1);
    bellman_ford(graph2, dis2, al2);
    long long sum = 0;//poj加了数据 题目原本用int就能处理开
    for (int p = 1; p <= P; p++)
        sum += dis1[p] + dis2[p];//加和即是结果
    return sum;
}
int main(void)
{
    //freopen("vs_cin.txt", "r", stdin);
    //freopen("vs_cout.txt", "w", stdout);

    int times;
    scanf("%d", &times);//input
    while (times--) {
        scanf("%d%d", &P, &Q);//input
        printf("%lld\n", fun());//output
        front = back = 0;//队列清零
    }
}

EOF