hdu_1598

本来我以为可以用搜索加剪枝搞定的，可敲了好久不停的剪枝，还是tle！！！唉，我不知道为什么那么强力的剪枝都会tle！！时间就这么一分一秒的浪费了，最后无奈，用了个二分加枚举加贪心，真不爽！

ac代码~

#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
using namespace std;
const int maxn=222;
int n,m,sum,start,end,l,r,t,maxs;    
const int inf=0x3f3f3f3f;
struct zz
{
    int from;
    int to;
    int speed;
}zx,tz;
vector<zz>g[maxn];
bool vis[maxn];
vector<int>v;
queue<int>q;

bool bfs(int lend,int rend)
{   
    memset(vis,false,sizeof(vis));
    while(!q.empty())
    {
        q.pop();
    }
    q.push(start);
    vis[start]=true;
    int now;
    if(start==end)
    {
        return true;
    }
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        for(int i=0;i<g[now].size();i++)
        {   
            if(g[now][i].speed > rend || g[now][i].speed < lend)
            {
                continue;
            }                   
            if(!vis[g[now][i].to])
            {   
                vis[g[now][i].to]=true;
                q.push(g[now][i].to);   
                if(g[now][i].to == end)
                {
                    return true;   
                } 
            }
        }       
    }
    return false;
}

int find()
{   
    l=0;
    r=maxs;
    int temp,mid;
    bool yes;
    if(!bfs(1,maxs))
    {
        return -1;
    }
    while( l <= r )
    {
        mid = (l+r)/2;
        if(mid==temp)
        {
            break;
        }         
        else
        {
            temp=mid;
        }          
        yes=false;    
        for(int i=0;v[i]+mid<=maxs;i++)
        {
            if(bfs(v[i],v[i]+mid))
            {
                yes=true;
                break; 
            }
        }
        if(yes)
        {
            r=mid;
        }
        else
        {
            l=mid+1;    
        }
    }
    return mid;
}
 
int main()
{
    while(cin>>n>>m)
    {
        v.clear();
        for(int i=1;i<=n;i++)
        {
            g[i].clear();
        }
        maxs=0;
        for(int i=1;i<=m;i++)
        {
            cin>>zx.from>>zx.to>>zx.speed;
            v.push_back(zx.speed);
            if(zx.speed > maxs)
            {   
                maxs=zx.speed;
            }
            g[zx.from].push_back(zx);
            swap(zx.from,zx.to);
            g[zx.from].push_back(zx);           
        }
        cin>>t;
        sort(v.begin(),v.end());
        for(int i=1;i<=t;i++)
        {
            cin>>start>>end;
            cout<<find()<<endl;   
        }
    }
    return 0;
}

然后是搜索的代码，我不知道为啥就会tle！！写递归都用直接用栈了有木有啊！！！！尼玛hdu还给我tle！！桑不起！！！

#include<vector>
#include<string>
#include<cstdio>
#include<iomanip>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#include<iostream>
using namespace std;
const int maxn=222;
const int inf=0x3f3f3f3f;
struct zz
{
    int from;
    int to;
    int speed;
    bool operator < (const zz& cmp) const
    {   
        return speed < cmp.speed; 
    }
}zx,tz;
struct zan
{
    int x;
    int tmin;
    int tmax; 
}ta,zanx;
int n,mm,sum,t,start,end,now;
vector<zz>g[maxn];
bool vis[maxn];
bool vis2[maxn];
stack<int>s2;
stack<zan>s;
int m[2][maxn];       //0最小，1最大 

inline void init()
{
    for(int i=1;i<=n;i++)
    {
        g[i].clear();
    }
    for(int i=1;i<=n;i++)
    {
        m[1][i]=inf;
        m[0][i]=0;
    }
    return ;
}

void dfs(int x,int tmin=inf,int tmax=0)
{
    m[0][x]=tmin;
    m[1][x]=tmax;
    if(x==end)  
    {
        if( tmax - tmin < sum )  
        {
            sum = tmax - tmin;
        }     
    }
    else
    {
        for(int i=0;i<g[x].size();i++)
        {
            if(!vis[g[x][i].to]) 
            {
                if( max ( tmax , g[x][i].speed ) - min ( g[x][i].speed , tmin ) > sum)
                {      
                    continue;
                }
                if ( min ( g[x][i].speed , tmin ) < m[0][g[x][i].to] && max ( tmax , g[x][i].speed ) > m[1][g[x][i].to] )
                {
                    continue;
                }
                else if(min ( g[x][i].speed , tmin ) > m[0][g[x][i].to] && max ( tmax , g[x][i].speed ) < m[1][g[x][i].to])
                {
                    m[0][g[x][i].to] = min ( g[x][i].speed , tmin ); 
                    m[1][g[x][i].to] = max ( tmax , g[x][i].speed ); 
                }
                vis [ g[x][i].to ] = true;
                dfs ( g[x][i].to , min ( g[x][i].speed , tmin ) , max (tmax , g[x][i].speed ) );
                vis [g[x][i].to] = false;   
            }                                                                                                                                                                                                                            
        }      
    }
    return ;
}
  

/*
bool dfs2(int x=start)
{
    if(x==end)
    {
        return true;    
    }    
    else
    {
        for(int i=0;i<g[x].size();i++)
        {
            if(!vis[g[x][i].to])
            {
                vis2[g[x][i].to]=true;
                if(dfs2(g[x][i].to))
                {
                    return true;
                }
            }
        }
        return false;
    }
}
*/

bool dfs2()
{   
    memset(vis2,false,sizeof(vis2));
    while(!s2.empty())    
    {
        s2.pop();
    }
    s2.push(start);
    vis2[start]=true;
    while(!s2.empty())
    {
        int now = s2.top();
        s2.pop();
        if(now == end)
        {
            return true;
        }
        for(int i=0;i < g[now].size();i++)
        {
            if(!vis2[g[now][i].to])
            {
                vis2[g[now][i].to]=true;
                s2.push(g[now][i].to);
            }
        }  
    }
    return false;
}


int main()
{
    while(cin>>n>>mm)
    {   
        init();
        for(int i=1;i<=mm;i++)    
        {
            cin>>zx.from>>zx.to>>zx.speed;
            g[zx.from].push_back(zx);
            swap(zx.from,zx.to);
            g[zx.from].push_back(zx);
        }     
        for(int i=1;i<=n;i++)
        {
            sort(g[i].begin(),g[i].end());    
        }
        cin>>t;
        for(int i=1;i<=t;i++)
        {   
            cin>>start>>end;
            sum=inf;
            memset(vis,false,sizeof(vis));
            memset(vis2,false,sizeof(vis2));
            vis2[start]=true;
            vis[start]=true;
            if(!dfs2())
            {
                cout<<"-1"<<endl;
            }
            else
            {
                for(int i=1;i<=n;i++)
                {
                    m[1][i]=inf;
                    m[0][i]=0;
                }
                dfs(start);
                cout<<sum<<endl;
            }            
        }
    }
    return 0;    
}