物流运输

题目

无数傻逼错误出现这一题。

码头数和天数一直搞反，偏偏样例还就是反了也是一个运行结果，

建图出现傻逼错误。

    for(int i = 0;i < e;i++)
    {
        int from,to,dist;
        scanf("%d%d%d",&from,&to,&dist);
        edges.push_back(Edge(from,to,dist));
        edges.push_back(Edge(to,from,dist));
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);        
    }

最短路再无法到达是返回固定值INF

最短路的思路：

预处理哪几天哪几个码头无法经过，每次dijkstra时处理一下时间段内那些码头不能到达，然后和vis数组一起判断一下就好了，最后返回

    return d[m] != INF?d[m]*(right-left+1):d[m];

然后就是dp的思路了

枚举天数k，计算从第一天到第k天的最短路，当然，是不变路线的最短路作为初始值，然后再枚举在第i天更换路线，再dp取一下最小值，

    for(int k = 1;k <= n;k++)
    {
        dp[k] = dijkstra(1,k); 
        for(int j = 2;j <= k;j++)
        {
                dp[k] = min(dp[k],dp[j-1]+dijkstra(j,k)+K);
        }
    }

最后痛的体验是自己维护代码能力已经垃圾到一种境界啦，真的调试能力是傻逼啊，代码风格丑的要死，一堆堆的全局变量堆来堆去，错了都不知道是该了全局变量，最后函数也不知道该怎么办，不彻底了解题意就自信输入必对，不是傻逼是什么，最后还就在输入等预处理上死了，

代码风格要改啊，多传几个参数能救命啊！！！！！！！

痛的回忆粘上代码，警示后人：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 1000;
const int INF = 0x7ffffff;
struct Edge
{
    int from,to,dist;
    Edge(int from,int to,int dist):from(from),to(to),dist(dist){}    
};
struct Heapnode
{
    int dist,to;
    bool operator <(const Heapnode& b) const
    {
        return dist > b.dist;
    }    
};
int n,m,K,e;
vector<Edge> edges;
vector<int> G[maxn];
int d[maxn];
int dp[maxn];　　　　　　　　　　//以后不要搞一堆全局变量。
bool able[maxn];
int disable[21][101];
void init(int left,int right);
int dijkstra(int left,int right);
int main()
{
    memset(disable,0,sizeof(disable));
    cin>>n>>m>>K>>e;
    for(int i = 0;i < e;i++)
    {
        int from,to,dist;
        scanf("%d%d%d",&from,&to,&dist);
        edges.push_back(Edge(from,to,dist));
        edges.push_back(Edge(to,from,dist));
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);        
    }    
    int num;
    scanf("%d",&num);
    for(int i = 0;i < num;i++)
    {
        int post,st,et;
        scanf("%d%d%d",&post,&st,&et);
        for(int j = st;j <= et;j++) disable[post][j] = 1;
    }
    for(int k = 1;k <= n;k++)
    {
        dp[k] = dijkstra(1,k); 
        for(int j = 2;j <= k;j++)
        {
                dp[k] = min(dp[k],dp[j-1]+dijkstra(j,k)+K);
        }
    }
    cout<<dp[n];    
    return 0;
}


void init(int left,int right)
{
    memset(able,true,sizeof(able));
    for(int k = 1;k <= m;k++)
        for(int i = left;i <= right;i++){
            if(disable[k][i] == 1){
                able[k] = false;
                break;    
            }
            
        }
    return;
}

int dijkstra(int left,int right)
{
    init(left,right);
    for(int i = 1;i <= m;i++) d[i] = INF;
    d[1] = 0;
    int vis[maxn];
    memset(vis,0,sizeof(vis));    
    priority_queue<Heapnode> Q;
    Q.push((Heapnode){0,1});
    while(!Q.empty())
    {
        Heapnode x = Q.top();Q.pop();
        int u = x.to;
        if(vis[u]||!(able[u])) continue;
        vis[u] = 1;
        for(int i = 0;i < G[u].size();i++)
        {
            Edge& e = edges[G[u][i]];
            if(d[u] + e.dist < d[e.to]){
                d[e.to] = d[u] + e.dist ;
                Q.push((Heapnode){d[e.to],e.to});
            }
        }
    } 
    return d[m] != INF?d[m]*(right-left+1):d[m];
}