2002-2003 ACM-ICPC Northeastern European Regional Contest (NEERC 02)

B Bricks 计算几何乱搞

题意：

给你个立方体，问你能不能放进一个管道里面。

题解：

这是一道非常迷的题，其问题在于，你可以不正着放下去，你需要斜着放。此时你需要枚举你旋转的角度，来判断是否可行。至于枚举的范围和步长，看脸乱搞。

代码：

//#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<fstream>
using namespace std;

long double x[],y[];

const long double pi=acos(-);

long double a,b;
long double d,e;

const long double eps=1e-;

int main() {
    ifstream cin("bricks.in");
    ofstream cout("bricks.out");
    cin.sync_with_stdio(false);
    cin >> x[] >> x[] >> x[] >> y[] >> y[];
    sort(x, x + );
    sort(y, y + );
    a = x[], b = x[];
    d = y[], e = y[];
    if (d - a > -eps && e - b > -eps) {
        cout << "YES" << endl;
        return ;
    }
    long double dd = pi / ( * (3e6));
    for (long double t = acos(e / b); t < asin(d / b) + dd; t += dd) {
        if (min((e - b * cos(t)) / sin(t), (d - b * sin(t)) / cos(t)) > a - eps) {
            cout << "YES" << endl;
            return ;
        }
    }
    cout << "NO" << endl;
    return ;
}

E Evacuation Plan 最小费用流

题意：

题目好长好长好长。。。。。简单说就是，发生核战争了，人们要避难，给你每个建筑的坐标，给你每个避难所的坐标，每个建筑里面有若干人，从一个建筑到一个避难所的时间，是坐标的曼哈顿距离，现在要你使总时间花费最少。

题解：

就最小费用的模板题。最后在残余网络上寻找解即可。

代码：

//#include <iostream>
#include<vector>
#include<fstream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<string>
#include<cmath>
#define MAX_V 222
#define INF 1008611
using namespace std;
struct edge {
public:
    int to, cap, cost, rev;
    bool isRev;

    edge(int t, int c, int co, int re,bool ir) : to(t), cap(c), cost(co), rev(re),isRev(ir) { }

    edge() { }
};
int V=;
vector<edge> G[MAX_V];
int dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];

void add_edge(int from,int to,int cap,int cost) {
    G[from].push_back(edge(to,cap,cost,G[to].size(),));
    G[to].push_back(edge(from,,-cost,G[from].size()-,));
}

char cc;
int min_cost_flow(int s,int t,int f) {
    int res = ;
    while (f > ) {
        fill(dist, dist + V, INF);
        dist[s] = ;
        bool update = ;
        while (update) {
            update = ;
            for (int v = ; v < V; v++) {
                if (dist[v] == INF)continue;
                for (int i = ; i < G[v].size(); i++) {
                    edge &e = G[v][i];
                    if (e.cap >  && dist[e.to] > dist[v] + e.cost) {
                        //cout<<"*"<<endl;
                        dist[e.to] = dist[v] + e.cost;
                        prevv[e.to] = v;
                        preve[e.to] = i;
                        update = ;
                    }
                }
            }
        }
        if (dist[t] == INF)
            return -;

        int d = f;
        for (int v = t; v != s; v = prevv[v])
            d = min(d, G[prevv[v]][preve[v]].cap);
        f -= d;
        res += d * dist[t];
        for (int v = t; v != s; v = prevv[v]) {
            edge &e = G[prevv[v]][preve[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }
    return res;
}

int n,m;

struct build {
public:
    int x, y,c;

    build(int xx, int yy,int cc) : x(xx), y(yy), c(cc){ }

    build() { }

    int dis(build a){
        return abs(a.x-x)+abs(a.y-y)+;
    }
};

typedef build shelter;

build bu[MAX_V];
shelter sh[MAX_V];

int plan;
int S=;

int main() {
    ifstream cin("evacuate.in");
    ofstream cout("evacuate.out");
    cin.sync_with_stdio(false);
    cin >> n >> m;
    for (int i = ; i < n; i++) {
        cin >> bu[i].x >> bu[i].y >> bu[i].c;
        S += bu[i].c;
    }
    for (int i = ; i < m; i++)
        cin >> sh[i].x >> sh[i].y >> sh[i].c;
    for (int i = ; i < n; i++)
        for (int j = ; j < m; j++) {
            int k;
            cin >> k;
            plan += k * bu[i].dis(sh[j]);
        }
    for (int i = ; i < n; i++)
        add_edge(n + m, i, bu[i].c, );
    for (int j = ; j < m; j++)
        add_edge(j + n, n + m + , sh[j].c, );
    for (int i = ; i < n; i++)
        for (int j = ; j < m; j++)
            add_edge(i, j + n, INF, bu[i].dis(sh[j]));
    V = n + m + ;
    int tmp = min_cost_flow(n + m, n + m + , S);
    if (tmp == plan) {
        cout << "OPTIMAL" << endl;
        return ;
    }
    cout << "SUBOPTIMAL" << endl;
    for (int i = ; i < n; i++, cout << endl)
        for (int j = ; j < G[i].size(); j++)
            if (!G[i][j].isRev)
                cout << INF - G[i][j].cap << " ";

    return ;
}

I Inlay Cutters 模拟+图论

题意：

给你一个棋盘，现在切若干刀，问你最后有几个三角形。

题解：

由于三个点在平面上只能构成三角形，那么此题可以转化为图论问题来解决，将相邻的直线交点连边，然后在图上求有多少个三元环即可。

代码：

//#include<iostream>
#include<fstream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<string>
#include<cmath>
#define MAX_N 10004
using namespace std;

int N,M,K;

int d[];

struct knife {
public:
    int from, to, dir;

    knife(int f, int t, int d) : from(f), to(t), dir(d) { }

    knife() { }
};

knife kn[MAX_N];

int cnt[MAX_N];

vector<int> G[MAX_N];

int main() {
    ifstream cin("inlay.in");
    ofstream cout("inlay.out");
    cin.sync_with_stdio(false);
    cin >> M >> N >> K;
    d[] =  * M + ;
    d[] = ;
    d[] = M + ;
    d[] = M;
    for (int i = ; i < K; i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        if (y1 > y2 || (y1 == y2 && x1 > x2)) {
            swap(x1, x2);
            swap(y1, y2);
        }
        int u = x1 * d[] + y1 * d[];
        int v = x2 * d[] + y2 * d[];
        int t;
        if (x1 == x2)t = ;
        else if (y1 == y2)t = ;
        else if (x2 > x1)t = ;
        else t = ;
        kn[i] = knife(u, v, t);
    }
    kn[K++] = knife(, M, );
    kn[K++] = knife(N * d[], N * d[] + M * d[], );
    kn[K++] = knife(, N * d[], );
    kn[K++] = knife(M, N * d[] + M, );
    for (int i = ; i < K; i++) {
        int u = kn[i].from, v = kn[i].to, t = kn[i].dir;
        while (u != v) {
            cnt[u]++;
            u += d[t];
        }
        cnt[v]++;
    }
    int V = -;
    for (int i = ; i < K; i++) {
        int u = kn[i].from, v = kn[i].to, t = kn[i].dir;
        int p = u;
        while (u != v) {
            u += d[t];
            if (cnt[u] > ) {
                V = max(V, u);
                V = max(V, p);
                G[p].push_back(u);
                G[u].push_back(p);
                p = u;
            }
        }
    }
    int ans = ;
    V++;
    for (int u = ; u < V; u++)
        sort(G[u].begin(), G[u].end());
    for (int u = ; u < V; u++)
        for (auto v:G[u])
            for (auto c:G[v]) {
                if (c == u)continue;
                int t = lower_bound(G[c].begin(), G[c].end(), u) - G[c].begin();
                if (G[c][t] == u)ans++;
                //cout<<c<<" "<<u<<" "<<v<<endl;
            }
    cout << ans/ << endl;
    return ;
}