【HDOJ】2155 小黑的镇魂曲

线段树+SPFA最短路可以过。或者DP也能过。
需要注意的是xl的范围是错的，测试用例中xl可能为0，他妈的，因为这个一直莫名其妙的wa。
1. spfa建图增加一倍的点即可（讨论左端点和右端点）。

 /* 2155 */
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <vector>
 #include <deque>
 #include <algorithm>
 #include <cstdio>
 #include <cmath>
 #include <ctime>
 #include <cstring>
 #include <climits>
 #include <cctype>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <iomanip>
 using namespace std;
 //#pragma comment(linker,"/STACK:102400000,1024000")

 #define sti                set<int>
 #define stpii            set<pair<int, int> >
 #define mpii            map<int,int>
 #define vi                vector<int>
 #define pii                pair<int,int>
 #define vpii            vector<pair<int,int> >
 #define rep(i, a, n)     for (int i=a;i<n;++i)
 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 #define clr                clear
 #define pb                 push_back
 #define mp                 make_pair
 #define fir                first
 #define sec                second
 #define all(x)             (x).begin(),(x).end()
 #define SZ(x)             ((int)(x).size())
 #define lson            l, mid, rt<<1
 #define rson            mid+1, r, rt<<1|1

 typedef struct {
     int v, w, nxt;
 } edge_t;

 typedef struct node_t {
     int xl, xr, y;

     node_t() {}
     node_t(int xl, int xr, int y):
         xl(xl), xr(xr), y(y) {}

     friend bool operator <(const node_t& a, const node_t& b) {
         return a.y < b.y;
     }

 } node_t;

 const int maxv = ;
 const int maxe = maxv * ;
 const int INF = 0x3f3f3f3f;
 int n, x, y, mx, T;
 edge_t E[maxe];
 int head[maxv<<];
 bool visit[maxv<<];
 int dis[maxv<<];
 node_t nd[maxv];
 int l = , m;
 int start, End;
 int ID[maxv<<];
 int L, R, id;

 void init() {
     l = ;
     m = ;
     memset(head, -, sizeof(head));
 }

 void addEdge(int u, int v, int w) {
     E[l].v = v;
     E[l].w = w;
     E[l].nxt = head[u];
     head[u] = l++;
 }

 void Build(int l, int r, int rt) {
     ID[rt] = ;
     if (l == r)
         return ;

     int mid = (l + r) >> ;
     Build(lson);
     Build(rson);
 }

 inline void PushDown(int rt) {
     if (ID[rt]) {
         ID[rt<<] = ID[rt<<|] = ID[rt];
         ID[rt] = ;
     }
 }

 void Update(int l, int r, int rt) {
     if (L<=l && R>=r) {
         ID[rt] = id;
         return ;
     }

     PushDown(rt);
     int mid = (l + r) >> ;

     if (R <= mid) {
         Update(lson);
     } else if (L > mid) {
         Update(rson);
     } else {
         Update(lson);
         Update(rson);
     }
 }

 int Query(int k, int l, int r, int rt) {
     if (l == r)
         return ID[rt];

     PushDown(rt);
     int mid = (l + r) >> ;

     if (k <= mid)
         return Query(k, lson);
     else
         return Query(k, rson);
 }

 int spfa() {
     queue<int> Q;
     int u, v, k;

     memset(visit, false, sizeof(visit));
     memset(dis, INF, sizeof(dis));
     dis[start] = ;
     visit[start] = true;
     Q.push(start);

     while (!Q.empty()) {
         u = Q.front();
         Q.pop();
         visit[u] = false;
         for (k=head[u]; k!=-; k=E[k].nxt) {
             v = E[k].v;
             if (dis[u]+E[k].w < dis[v]) {
                 dis[v] = dis[u] + E[k].w;
                 if (!visit[v]) {
                     visit[v] = true;
                     Q.push(v);
                 }
             }
         }
     }

     return dis[End];
 }

 int main() {
     ios::sync_with_stdio(false);
     #ifndef ONLINE_JUDGE
         freopen("data.in", "r", stdin);
         freopen("data.out", "w", stdout);
     #endif

     int t;
     int lid, rid;
     int tmp, w;

     scanf("%d", &t);
     rep(tt, , t+) {
         scanf("%d %d %d %d %d", &n, &x, &y, &mx, &T);
         ++x;
         init();
         rep(i, , n) {
             scanf("%d %d %d", &nd[m].xl, &nd[m].xr, &nd[m].y);
             ++nd[m].xl;
             ++nd[m].xr;
             if (nd[m].y < y)
                 ++m;
         }

         nd[m].xl = x;
         nd[m].xr = x;
         nd[m].y = y;
         ++m;
         nd[m].xl = ;
         nd[m].xr = ;
         nd[m].y = ;
         sort(nd+, nd++m);
         End = ;
         start = m;
         memset(ID, , sizeof(ID));

         L = nd[].xl;
         R = nd[].xr;
         id = ;
         Update(, , );
         rep(i, , m+) {

             // handle left
             L = nd[i].xl;
             lid = Query(L, , , );
             tmp = nd[i].y - nd[lid].y;
             if (tmp <= mx) {
                 if (lid == End) {
                     w = tmp;
                     addEdge(i, lid, w);
                 } else {
                     // to left of lid
                     w = tmp + nd[i].xl - nd[lid].xl;
                     addEdge(i, lid, w);

                     // to right of lid
                     w = tmp + nd[lid].xr - nd[i].xl;
                     addEdge(i, lid+m, w);
                 }
             }

             // handle right
             if (i != m) {
                 R = nd[i].xr;
                 rid = Query(R, , , );
                 tmp = nd[i].y - nd[rid].y;
                 if (tmp <= mx) {
                     if (rid == End) {
                         w = tmp;
                         addEdge(i+m, rid, w);
                     } else {
                         // to left of rid
                         w = tmp + nd[i].xr - nd[rid].xl;
                         addEdge(i+m, rid, w);

                         // to right of rid
                         w = tmp + nd[rid].xr - nd[i].xr;
                         addEdge(i+m, rid+m, w);
                     }
                 }
             }

             L = nd[i].xl;
             R = nd[i].xr;
             id = i;

             Update(, , );
         }

         tmp = spfa();
         if (tmp==INF || tmp>T)
             puts("YES");
         else
             puts("NO");
     }

     #ifndef ONLINE_JUDGE
         printf("time = %d.\n", (int)clock());
     #endif

     return ;
 }

2. DP, 二维DP，没什么好说的。

 /* 2155 */
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <vector>
 #include <deque>
 #include <algorithm>
 #include <cstdio>
 #include <cmath>
 #include <ctime>
 #include <cstring>
 #include <climits>
 #include <cctype>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <iomanip>
 using namespace std;
 //#pragma comment(linker,"/STACK:102400000,1024000")

 #define sti                set<int>
 #define stpii            set<pair<int, int> >
 #define mpii            map<int,int>
 #define vi                vector<int>
 #define pii                pair<int,int>
 #define vpii            vector<pair<int,int> >
 #define rep(i, a, n)     for (int i=a;i<n;++i)
 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 #define clr                clear
 #define pb                 push_back
 #define mp                 make_pair
 #define fir                first
 #define sec                second
 #define all(x)             (x).begin(),(x).end()
 #define SZ(x)             ((int)(x).size())
 #define lson            l, mid, rt<<1
 #define rson            mid+1, r, rt<<1|1

 typedef struct node_t {
     int l, r, h;

     node_t() {}
     node_t(int l, int r, int h):
         l(l), r(r), h(h) {}

     friend bool operator< (const node_t& a, const node_t& b) {
         return a.h > b.h;
     }

 } node_t;

 const int maxn = ;
 const int INF = 0x3f3f3f3f;
 node_t nd[maxn];
 int dp[maxn][];
 int n, x, y, mx, T;

 void solve() {
     bool fl, fr;
     int tmp;

     memset(dp, INF, sizeof(dp));
     dp[][] = dp[][] = ;
     rep(i, , n) {
         #ifndef ONLINE_JUDGE
             printf("l = %d, r = %d, [0] = %d, [1] = %d\n", nd[i].l, nd[i].r, dp[i][], dp[i][]);
         #endif
         fl = fr = true;
         rep(j, i+, n+) {
             tmp = nd[i].h - nd[j].h;
             if (tmp > mx)
                 break;
             if (fl && nd[j].l<=nd[i].l && nd[i].l<=nd[j].r) {
                 fl = false;
                 if (j == n) {
                     dp[j][] = min(dp[j][], dp[i][]+tmp);
                     dp[j][] = min(dp[j][], dp[i][]+tmp);
                 } else {
                     dp[j][] = min(dp[j][], dp[i][]+tmp+nd[i].l-nd[j].l);
                     dp[j][] = min(dp[j][], dp[i][]+tmp+nd[j].r-nd[i].l);
                 }
             }
             if (fr && nd[j].l<=nd[i].r && nd[i].r<=nd[j].r) {
                 fr = false;
                 if (j == n) {
                     dp[j][] = min(dp[j][], dp[i][]+tmp);
                     dp[j][] = min(dp[j][], dp[i][]+tmp);
                 } else {
                     dp[j][] = min(dp[j][], dp[i][]+tmp+nd[i].r-nd[j].l);
                     dp[j][] = min(dp[j][], dp[i][]+tmp+nd[j].r-nd[i].r);
                 }
             }
         }
     }

     if (dp[n][]<=T || dp[n][]<=T)
         puts("NO");
     else
         puts("YES");
 }

 int main() {
     ios::sync_with_stdio(false);
     #ifndef ONLINE_JUDGE
         freopen("data.in", "r", stdin);
         freopen("data.out", "w", stdout);
     #endif

     int t;

     scanf("%d", &t);
     while (t--) {
         scanf("%d %d %d %d %d", &n, &x, &y, &mx, &T);
         nd[].l = nd[].r = x;
         nd[].h = y;
         rep(i, , n+)
             scanf("%d %d %d", &nd[i].l, &nd[i].r, &nd[i].h);
         sort(nd, nd+n);
         ++n;
         nd[n].l = ;
         nd[n].r = ;
         nd[n].h = ;
         solve();
     }

     #ifndef ONLINE_JUDGE
         printf("time = %d.\n", (int)clock());
     #endif

     return ;
 }