2019/round1/ladders_and_snakes.cpp

// Ladders and Snakes
// Solution by Jacob Plachta
 
#define DEBUG 0
 
#include <algorithm>
#include <functional>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cassert>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <sstream>
using namespace std;
 
#define LL long long
#define LD long double
#define PR pair<int,int>
 
#define Fox(i,n) for (i=0; i<n; i++)
#define Fox1(i,n) for (i=1; i<=n; i++)
#define FoxI(i,a,b) for (i=a; i<=b; i++)
#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
#define FoxR1(i,n) for (i=n; i>0; i--)
#define FoxRI(i,a,b) for (i=b; i>=a; i--)
#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
#define Min(a,b) a=min(a,b)
#define Max(a,b) a=max(a,b)
#define Sz(s) int((s).size())
#define All(s) (s).begin(),(s).end()
#define Fill(s,v) memset(s,v,sizeof(s))
#define pb push_back
#define mp make_pair
#define x first
#define y second
 
template<typename T> T Abs(T x) { return(x<0 ? -x : x); }
template<typename T> T Sqr(T x) { return(x*x); }
string plural(string s) { return(Sz(s) && s[Sz(s)-1]=='x' ? s+"en" : s+"s"); }
 
const int INF = (int)1e9;
const LD EPS = 1e-12;
const LD PI = acos(-1.0);
 
#if DEBUG
#define GETCHAR getchar
#else
#define GETCHAR getchar_unlocked
#endif
 
bool Read(int &x)

{
    char c,r=0,n=0;
    x=0;
        for(;;)
        {
            c=GETCHAR();
                if ((c<0) && (!r))
                    return(0);
                if ((c=='-') && (!r))
                    n=1;
                else
                if ((c>='0') && (c<='9'))
                    x=x*10+c-'0',r=1;
                else
                if (r)
                    break;
        }
        if (n)
            x=-x;
    return(1);
}
 
#define LIM 50
 
struct Dinic {
	struct Edge {
		int to, rev, c, f;
		Edge(int to, int rev, int c, int f) : to(to), rev(rev), c(c), f(f) {}
	};
	vector<int> lvl, ptr, q;
	vector< vector<Edge> > adj;
	
	Dinic(int n) : lvl(n), ptr(n), q(n), adj(n) {}
	
	void addEdge(int a, int b, int c) {
		adj[a].pb(Edge(b, Sz(adj[b]), c, 0));
		adj[b].pb(Edge(a, Sz(adj[a]) - 1, 0, 0));
	}
	
	int dfs(int v, int t, int f) {
		if (v == t || !f) return f;
		for (int& i = ptr[v]; i < Sz(adj[v]); i++) {
			Edge& e = adj[v][i];
			if (lvl[e.to] == lvl[v] + 1) {
				if (int p = dfs(e.to, t, min(f, e.c - e.f))) {
					e.f += p, adj[e.to][e.rev].f -= p;
					return p;
				}
			}
		}
		return 0;
	}
	
	int calc(int s, int t) {
		int L, flow = 0; q[0] = s;
		Fox(L,31) {
			do {
				lvl = ptr = vector<int>(Sz(q));
				int qi = 0, qe = lvl[s] = 1;
				while (qi < qe && !lvl[t]) {
					int i, v = q[qi++];
					Fox(i,Sz(adj[v])) {
						Edge e=adj[v][i];
						if (!lvl[e.to] && (e.c - e.f) >> (30 - L)) {
							q[qe++] = e.to, lvl[e.to] = lvl[v] + 1;
						}
					}
				}
				while (int p = dfs(s, t, INF)) flow += p;
			} while (lvl[t]);
		}
		return flow;
	}
};
 
int main()

{
        if (DEBUG)
            freopen("in.txt","r",stdin);
    // vars
    int T,t;
    int N,H;
    int i,j,k;
    int X[LIM],A[LIM],B[LIM];
    // testcase loop
    Read(T);
        Fox1(t,T)
        {
            // input
            Read(N),Read(H);
                Fox(i,N)
                    Read(X[i]),Read(A[i]),Read(B[i]);
            // construct flow graph
            Dinic D(N+2);
                Fox(i,N)
                {
                    // connected to bottom?
                        if (A[i]==0)
                            D.addEdge(N,i,1e7);
                    // connected to top?
                        if (B[i]==H)
                            D.addEdge(i,N+1,1e7);
                    // consider connections to other ladders
                        Fox(j,N)
                            if (X[i]<X[j])
                            {
                                // compute combined length of connecting, unobstructed y-coordinate intervals
                                vector<pair<int,PR> > E;
                                    Fox(k,N)
                                        if ((X[i]<=X[k]) && (X[k]<=X[j]))
                                        {
                                            E.pb(mp(A[k],mp(1,k)));
                                            E.pb(mp(B[k],mp(0,k)));
                                        }
                                int s=0;
                                set<int> S;
                                sort(All(E));
                                    Fox(k,Sz(E))
                                    {
                                        if (E[k].y.x)
                                            S.insert(E[k].y.y);
                                        else
                                            S.erase(E[k].y.y);
                                        if ((Sz(S)==2) && (S.count(i)) && (S.count(j)))
                                            s+=E[k+1].x-E[k].x;
                                    }
                                    if (s)
                                    {
                                        D.addEdge(i,j,s);
                                        D.addEdge(j,i,s);
                                    }
                            }
                }
            // compute min cut
            int ans=D.calc(N,N+1);
                if (ans>=1e7)
                    ans=-1;
            // output
            printf("Case #%d: %d\n",t,ans);
        }
    return(0);
}