Topcoder WarTransportation 最短路转移dp

题目链接

方法一

 

　　这道题的题意真的难理解，想了很久都没懂什么叫最小值最大......

　　读完题一定要看样例！

　　题目可以理解为：有甲要走最短路，乙在甲走到某一顶点v时可以删去一条v----->u的边，两人博弈，甲走的路最短为多少？

　　分析一下数据范围可以发现n≤100，m≤500，O（n³）的算法都可以过

　　我们可以先预处理出对于每一顶点V，当甲走到V时，乙去掉一条V的出边，此时甲从V到2的最短路长，记为bad[v]

　　dp[v]为v的子图中删去一条边甲可以走的最短路

　　　　①删去一条v的出边

　　　　②删去v的子图中的其它出边

　　所以dp[v]=max{bad[v],min{dp[u]+cost(u,v)|v到u有边} }

　　可以通过最短路转移

　　复杂度O（n log n）

#include<bits/stdc++.h>
using namespace std;
#define F first
#define S second
struct     WarTransportation
{
    vector<pair<int,int> >nei[105],nei2[105];
    int bad[105];
    bool vis[105];
    int dijdis[105],n;
    int dij(int st,int cant)
    {
        for(int i=0;i<104;i++) dijdis[i]=1e9;
        memset(vis,0,sizeof vis);
        dijdis[st]=0;
        priority_queue<pair<int,int> > q;
        q.push(make_pair(0,st));
        while(!q.empty())
        {
            pair<int,int> tmp=q.top();
            q.pop();
            if(vis[tmp.S]) continue;
            tmp.F=-tmp.F;            
            int v=tmp.S;
            vis[v]=1;
            if(tmp.S==1) return dijdis[1];
            for(int i=0;i<nei[v].size();i++)
            {
                if(v==st&&i==cant) continue;                
                int u=nei[v][i].F,cost=dijdis[v]+nei[v][i].S;
                if(cost>=dijdis[u]) continue;
                dijdis[u]=cost;
                q.push(make_pair(-cost,u));
            }
        }
        //这里要返回inf 
        return 1e9;
    }
    void getbad()
    {
        for(int i=0;i<n;i++)
        {
            int fir=0;
            for(int j=0;j<nei[i].size();j++)
            {
                int x=dij(i,j);
                if(x>fir) fir=x;
            } 
            bad[i]=fir;
        }
    }
    int dp[105];
    int messenger(int yy,vector<string> v)
    {
        n=yy;
        int m;
        stringstream ss;
        //要熟悉stringstream的用法！ 
        for(int i=0;i<v.size();i++)
        {
            ss<<v[i];
        }int x,y,co;
        for(;ss>>x>>y>>co;)
        {
            m++;
            x--;y--;
            nei[x].push_back(make_pair(y,co));
            nei2[y].push_back(make_pair(x,co));
            char c;
            ss>>c;
        }
        getbad();
        memset(dp,-1,sizeof dp);
        priority_queue<pair<int,int> >q;
        q.push(make_pair(-bad[1],1));
        for(int i=0;i<104;i++)dp[i]=2e9;
        dp[1]=0;
        memset(vis,0,sizeof vis);
        while(!q.empty())
        {
            pair<int,int>tmp=q.top();
            q.pop();
            if(vis[tmp.S]) continue;
            int v=tmp.S;
            vis[v]=1;
            for(int i=0;i<nei2[v].size();i++)
            {
                int u=nei2[v][i].F,cost=max(bad[u],nei2[v][i].S+dp[v]);
                if(cost>=dp[u]) continue;
                dp[u]=cost;
                q.push(make_pair(-cost,u));
            }
        }
        return (dp[0]<1e9)?dp[0]:-1;
    }
};

 

方法二

　　要使最小值最大，我们也可以考虑二分答案。

　　可以二分在最坏情况下，最短路能不能小于T

　　直接跑最短路，能够转移的条件为dist[v]+cost(v,u)+bad[u]<=T&&dist[v]+cost(v,u)<dist[u]

　　复杂度O（n log² n）

typedef int             vert;
typedef int             cost;
typedef pair<cost,vert> edge;
typedef vector<edge>    edges;
typedef vector<edges>   graph;

static const cost INF   = 0x12345678; // large enough but INF+INF<2^31
static const vert START = 0;
static const vert GOAL  = 1;

class WarTransportation { public:
   int messenger(int n, vector <string> highways) 
   {
      return solve( parse(n, highways) );
   }

   graph parse(int n, vector <string> highways)
   {
      graph G(n);

      string hi = accumulate(highways.begin(), highways.end(), string());
      for(int i=0; i<hi.size(); )
      {
         int k = hi.find(',', i);
         if( k == string::npos ) k = hi.size();

         int a, b, c;
         stringstream(hi.substr(i,k-i)) >> a >> b >> c;
         G[a-1].push_back( edge(c,b-1) );

         i = k+1;
      }

      return G;
   }

   int solve( const graph& G )
   {
      // Suppose you reached the city "v", and found there the most critical load is broken.
      // How long will it take a detour to the GOAL?  It's ukai[v]!

      vector<cost> ukai;
      for(int v=0; v<G.size(); ++v)
         ukai.push_back( ukaiDist(G,v) );

      // Compute the least T such that:
      //   we get to the GOAL, making the worst case time <= T?

      cost L=0, R=99999999;
      if( !reachable(G, ukai, R) ) return -1;
      if(  reachable(G, ukai, L) ) return 0;

      // We can when T=R, and cannot T=L. 
      // That is, T in (L, R]. Now let's binary-search!

      while( R-L>1 )
         (reachable(G, ukai, (L+R)/2) ? R : L) = (L+R)/2;
      return R;
   }

   cost ukaiDist( const graph& G, vert v )
   {
      if( v == GOAL )        return 0;
      if( G[v].size() == 0 ) return INF;

      cost worst = 0;
      for(int f=0; f<G[v].size(); ++f) // f : broken road
      {
         priority_queue< edge, vector<edge>, greater<edge> > Q;
         set<vert> V;
         V.insert(v);
         for(int i=0; i<G[v].size(); ++i) // push all loads from v, except f
            if( i != f )
               Q.push( G[v][i] );
         worst = max( worst, dijkstra(G,Q,V) ); // start dijkstraing
      }
      return worst;
   }


   bool reachable( const graph& G, const vector<cost>& ukai, cost ukaiLimit )
   {
      priority_queue< edge, vector<edge>, greater<edge> > Q;
      set<vert> V;
      Q.push( edge(0,START) );
      return dijkstra(G, Q, V, ukai, ukaiLimit) != INF;
   }

   cost dijkstra( const graph& G,
      priority_queue< edge, vector<edge>, greater<edge> >& Q, set<vert>& V,
      const vector<cost>& ukai=vector<cost>(), cost ukaiLimit=-1
   ) {
      while( !Q.empty() )
      {
         // pop
         cost c = Q.top().first;
         vert v = Q.top().second;
         Q.pop();

         // check
         if( V.count(v) || (ukaiLimit>=0 && c+ukai[v]>ukaiLimit) )
            continue;
         if( v == GOAL )
             return c;
         V.insert(v);

         // next
         for(int i=0; i<G[v].size(); ++i)
            if( !V.count(G[v][i].second) )
               Q.push( edge(c+G[v][i].first, G[v][i].second) );
      }
      return INF;
   }
};