dp 略难 poj1661

这个题目状态就是每块板到左边和到右边的最短时间 然后转移的时候要对结构体排序高度从大到小 可以递推过来 也可以用记忆搜索 

做这个题目的时候wa了好长时间 后来才意识到转移的时候中间不能有别的板挡着。。。。。 然后里面写了个循环暴力 但是tle了 怎么办？

优化一下代码 想一下随即数据很容易产生覆盖的 然后两边都不能合法转移了 所以那么多循环次数没用 当两个都为0之后直接跳出循环就好了

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <sstream>
#include <ostream>
#include <list>
#include <ctype.h>
#include <cmath>
#define inf 2000000007
using namespace std;
struct node{
    int h;int left;int right;int lefttime;int righttime;int ok;
};
node dp[2005];
int cmp(node a,node b) {return a.h>b.h;}
int main()
{
    int t;cin>>t;
    while(t--)
    {
        memset(dp,0,sizeof(dp));
        int n,x,y,maxx,start=-1;
        cin>>n>>x>>y>>maxx;
        if(n==0)
        {cout<<y<<endl;continue;}
        for(int i=1;i<=n;i++)
        {
            cin>>dp[i].left>>dp[i].right>>dp[i].h;
            dp[i].ok=0;
            dp[i].lefttime=inf;
            dp[i].righttime=inf;
        }
        sort(dp+1,dp+n+1,cmp);
        for(int i=1;i<=n;i++)
            if(x<=dp[i].right&&x>=dp[i].left)
            {
                int time=(y-dp[i].h);
                dp[i].lefttime=time+(x-dp[i].left);
                dp[i].righttime=time+(dp[i].right-x);
                start=i;
                break;
            }
        if(start==-1) {cout<<y<<endl;continue;}
        dp[start].ok=1;
        for(int i=start+1;i<=n;i++)
        {
            for(int j=start;j<i;j++)
            {
                int okleft=1;int okright=1;
                for(int k=j+1;k<i;k++)//
                {
                    if(okleft==0&&okright==0) break;
                    if(dp[k].right>dp[j].left&&dp[k].left<dp[j].left) okleft=0;
                    if(dp[k].right>dp[j].right&&dp[k].left<dp[j].right) okright=0;
                }//这是判断是否可以转移的 也就是下落的函数 暴力写的 过了。。。
                int deltah=dp[j].h-dp[i].h;
                if(dp[j].ok&&dp[j].h-dp[i].h<=maxx)
                {
                    if(dp[i].left<=dp[j].left&&dp[i].right>=dp[j].left&&okleft)
                    {
                        int rtime=dp[j].lefttime+deltah+dp[i].right-dp[j].left;
                        int ltime=dp[j].lefttime+deltah+dp[j].left-dp[i].left;
                        dp[i].lefttime=min(dp[i].lefttime,ltime);
                        dp[i].righttime=min(dp[i].righttime,rtime);
                    }
                    if(dp[i].left<=dp[j].right&&dp[i].right>=dp[j].right&&okright)
                    {
                        int rtime=dp[j].righttime+deltah+dp[i].right-dp[j].right;
                        int ltime=dp[j].righttime+deltah+dp[j].right-dp[i].left;
                        dp[i].lefttime=min(dp[i].lefttime,ltime);
                        dp[i].righttime=min(dp[i].righttime,rtime);
                    }
                }
            
            }
            if(dp[i].lefttime!=inf) dp[i].ok=1;
        }//转移的过程
        int xiao=inf;
        for(int i=n;i>=1;i--)
        {
              if(dp[i].ok&&dp[i].h<=maxx)
               {
                    int okleft=1;int okright=1;
                    for(int j=n;j>i;j--)
                    {
                        if(dp[j].left<=dp[i].right&&dp[i].right<=dp[j].right) okright=0;
                        if(dp[i].left>=dp[j].left&&dp[i].left<=dp[j].right) okleft=0;
                    }
                   if(okleft) xiao=min(xiao,dp[i].lefttime+dp[i].h);
                   if(okright) xiao=min(xiao,dp[i].righttime+dp[i].h);
           }
        }//寻找最优解
        cout<<xiao<<endl;
    }
    return 0;
}