UCF Local Programming Contest 2016 补完了（太菜了）

A

#include <bits/stdc++.h>
using namespace std;

int n, a, b, c;

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d%d%d", &a, &b, &c);
        int cnt = 0;
        if (a >= 10) ++cnt;
        if (b >= 10) ++cnt;
        if (c >= 10) ++cnt;
        if (i != 1) puts("");
        printf("%d %d %d
", a, b, c);
        if (cnt == 0) puts("zilch");
        else if (cnt == 1) puts("double");
        else if (cnt == 2) puts("double-double");
        else puts("triple-double");
    }
    return 0;
}

　　

B

#include <bits/stdc++.h>
using namespace std;

int t, n;
int f[26];
char a[3], b[3], s[55];

int find(int x)
{
    if (x == f[x]) return x;
    return f[x] = find(f[x]);
}

bool same(int x, int y)
{
    x = find(x), y = find(y);
    return x == y;
}

void unit(int x, int y)
{
    x = find(x), y = find(y);
    f[y] = x;
}

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        if (cas != 1) puts("");
        printf("Test case #%d:
", cas);
        for (int i = 0; i < 26; ++i) f[i] = i;
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i)
        {
            scanf("%s%s", a + 1, b + 1);
            unit(a[1] - 'a', b[1] - 'a');
        }
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i)
        {
            scanf("%s", s + 1);
            printf("%s ", s + 1);
            int len = strlen(s + 1), flag = 1;
            for (int i = 1, j = len; i < j; ++i, --j)
                if (!same(s[i] - 'a', s[j] - 'a')) { flag = 0; break; }
            if (flag) puts("YES");
            else puts("NO");
        }
    }
    return 0;
}

　　

C

#include <bits/stdc++.h>
using namespace std;

int h[55], l[55], t, n, k;

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        if (cas != 1) puts("");
        int ans = 0;
        scanf("%d%d", &n, &k);
        for (int i = 1; i <= n; ++i) h[i] = l[i] = 0;
        for (int i = 1; i <= k; ++i)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            if (h[a] && l[b]) ++ans;
            h[a] = l[b] = 1;
        }
        printf("Strategy #%d: %d
", cas, ans);
    }
    return 0;
}

　　

D

#include <bits/stdc++.h>
#define ll long long
using namespace std;

int t, n, m, k, g;
ll sum[25];

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        if (cas != 1) puts("");
        printf("CD #%d:
", cas);
        scanf("%d%d", &n, &k);
        for (int i = 1; i <= n; ++i) scanf("%d", &m), sum[i] = sum[i - 1] + m;
        scanf("%d", &m);
        for (int i = 1; i <= m; ++i)
        {
            scanf("%d", &g); ll ans = 0;
            for (int j = 1, c; j <= g; ++j)
            {
                int a; scanf("%d", &a);
                if (j & 1) ans += a, c = sum[k] - sum[k - 1] -  a % (sum[k] - sum[k - 1]);
                else
                {
                    if (c == sum[k] - sum[k - 1]) c = 0;
                    if (a <= c) {ans += a; continue;}
                    a -= c, ans += c;
                    ans += a / sum[n] * (sum[k] - sum[k - 1]);
                    a = a % sum[n] - (sum[n] - sum[k] + sum[k - 1]);
                    if (a > 0) ans += a;
                }
            }
            printf("%lld
", ans);
        }
    }
    return 0;
}

　　

E

#include <bits/stdc++.h>
#define P pair<int, int>
using namespace std;

int n, m, cnt, tot, k, t;
int mp[25][25], d[4][2] = { {0,1}, {0,-1}, {1,0}, {-1, 0} };
char s[105], ans[5] = "RLDU";

bool work(int de, P p)
{
    for (int i = 2; s[i]; ++i)
    {
        p.first += d[de][0], p.second += d[de][1];
        if (p.first < 1) p.first = n;
        else if (p.first > n) p.first = 1;
        if (p.second < 1) p.second = m;
        else if (p.second > m) p.second = 1;
        if (mp[p.first][p.second] != s[i] - 'A') return false;
    }
    return true;
}

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        vector<P> ve[26];
        if (cas != 1) puts("");
        printf("Word search puzzle #%d:
", cas);
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= m; ++j)
            {
                char c = getchar();
                while (c > 'Z' || c < 'A') c = getchar();
                mp[i][j] = c - 'A';
                ve[c - 'A'].push_back({ i, j });
            }
        scanf("%d", &k);
        for (int i = 1; i <= k; ++i)
        {
            scanf("%s", s + 1);
            int ch = s[1] - 'A', flag = 1;
            for (P p : ve[ch])
            {
                for (int de = 0; de < 4; ++de)
                    if (work(de, p))
                    {
                        printf("%c %d %d %s
", ans[de], p.first, p.second, s + 1);
                        flag = 0;
                        break;
                    }
                if (!flag) break;
            }
        }
    }
    return 0;
}

　　

F(eps用多了误差就大了)

#include <bits/stdc++.h>
#define P pair<double, double>
#define eps 1e-6
using namespace std;

int n, t;
P p[55];

double dis(P a, P b)
{
    return (a.first - b.first) * (a.first - b.first) + 
            (a.second - b.second) * (a.second - b.second);
}

bool same(double a, double b)
{
    return abs(a - b) <= eps;
}

bool same(P a, P b)
{
    return (same(a.first, b.first) && same(a.second, b.second));
}

bool is(P a, P b, P c)
{
    return same(dis(a, c), dis(a, b) + dis(b, c));
}

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) scanf("%lf%lf", &p[i].first, &p[i].second);
        int ans = 0;
        for (int i = 1; i <= n; ++i)
            for (int j = i + 1; j <= n; ++j)
                for (int k = 1; k <= n; ++k)
                    if (k != i && k != j)
                    {
                        P mid = { (p[i].first + p[j].first) / 2,
                                 (p[i].second + p[j].second) / 2 };
                        if (!same(mid, p[k])) continue;
                        for (int x = 1; x <= n; ++x)
                            if (x != i && x != j && x != k)
                            {
                                if (same(dis(p[x], p[k]), dis(p[i], p[j])) &&
                                    is(p[i], p[k], p[x])) ++ans;
                            }
                    }
        if (cas != 1) puts("");
        printf("Set #%d: %d
", cas, ans);
    }
    return 0;
}

　　

G

(在A，B都能防御的时候，要分情况要么A防御，要么B，所以分两组（A,B）和（B、A），当一情况（二者都能防御且漏刀数小于等于另一种情况）则把另一种情况直接转换到当前情景（两者都能防御）然后继续分两组)

#include <bits/stdc++.h>
using namespace std;

int n, t, a[1005], m, b[3];

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        scanf("%d", &n);
        int ans = 0, lans = 0;
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        sort(a + 1, a + 1 + n);
        scanf("%d", &m);
        int x = 0, y = 0, lx = 0, ly = 0;
        for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
        if (m == 1)
            for (int i = 1; i <= n; ++i)
                if (x <= a[i]) x = a[i] + b[1];
                else ++ans;
        else
            for (int i = 1; i <= n; ++i)
            {
               if (lx <= a[i] && ly <= a[i] && lans <= ans)
                   ans = lans, x = lx, y = ly;
                if (x <= a[i] && y <= a[i] && ans <= lans)
                    lans = ans, lx = x, ly = y;
                if (x <= a[i]) x = a[i] + b[1];
                else if (y <= a[i]) y = a[i] + b[2];
                else ++ans;
                if (ly <= a[i]) ly = a[i] + b[2];
                else if (lx <= a[i]) lx = a[i] + b[1];
                else ++lans;
            }
        if (cas != 1) puts("");
        if (m != 1) printf("Mission #%d: %d
", cas, min(ans, lans));
        else printf("Mission #%d: %d
", cas, ans);
    }
    return 0;
}

　　

H

#include <bits/stdc++.h>
#define ll long long
using namespace std;

const int maxn = 1e7 + 5;

int n, t, a[maxn], x;

int main()
{
      scanf("%d", &t);
    for(int cas = 1; cas <= t; ++cas)
    {
        ll ans=0; int mx = 0;
        scanf("%d",&n);    
        memset(a,0,sizeof(a));
        for(int i = 1; i <= n; ++i) scanf("%d", &x), ++a[x], mx = max(mx, x);
        ans += (ll)a[0] * (n - a[0]) + (ll)a[1] * (n - a[0] - a[1]);
        for(int i = 2; i <= mx; ++i)
            if(a[i])
                for(int j = 2; j <= mx / i; ++j) ans += (ll)a[i] * a[j * i];
        printf("Test case #%d: %lld

", cas, ans);
    } 
    return 0;
}

　　

I

#include <bits/stdc++.h>
#define ll long long
#define P pair<int, int>
using namespace std;

int n, m, k, t, tot;
int mod = 1000000007;
int cnt[20];
P p[20];

ll dfs(int k, int tota)
{
    if (tota == n) { return 1; }
    ll ans = 0;
    for (int i = 1; i <= tot; ++i)
        if (cnt[i] && (p[i].first == k || p[i].second == k))
        {
            ll res = 0;
            --cnt[i];
            res = dfs(p[i].first == k ? p[i].second : p[i].first, tota + 1);
            ++cnt[i];
            ans += res * cnt[i];
        }
    return ans;
}

int main()
{
    scanf("%d", &t);
    for (int cas = 1; cas <= t; ++cas)
    {
        scanf("%d", &n);
        tot = 0;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d%d", &p[i].first, &p[i].second);
            if (p[i].first > p[i].second) swap(p[i].first, p[i].second);
            cnt[i] = 0;
        }
        sort(p + 1, p + 1 + n);
        for (int i = 1; i <= n; ++i)
        {
            int j = i;
            while (i + 1 <= n && p[i] == p[i + 1]) ++i;
            p[++tot] = p[i], cnt[tot] = i - j + 1;
        }
        ll ans = 0;
        for (int i = 1; i <= tot; ++i)
        {
            --cnt[i];
            ll res = dfs(p[i].first, 1);
            if (p[i].first != p[i].second) res += dfs(p[i].second, 1);
            ++cnt[i];
            ans += res * cnt[i];
        }
        int flag = (tot == 1 && p[1].first != p[1].second);
        printf("%lld", (ans >> flag) % mod);
        if (cas < t) puts("");
    }
    return 0;
}

　　

 J

#include <bits/stdc++.h>
#define P pair<int, int>
#define PP pair<int, P>
using namespace std;

int t, n, m;
int mp[505][505], vis[505][505];
int d[4][2] = { {1, 0}, {-1, 0}, {0, 1} , {0, -1} };

bool check(int mid)
{
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j) vis[i][j] = 0;
    vis[1][1] = 1;
    queue<PP> q; q.push({ 1, {1, 1} });
    while (!q.empty())
    {
        int dis = q.front().first;
        P p = q.front().second; q.pop();
        for (int i = 0; i < 4; ++i)
        {
            int x = p.first + d[i][0], y = p.second + d[i][1];
            if (x < 1 || x > n || y < 1 || y > m) continue;
            if (mp[x][y] - dis < mid || vis[x][y]) continue;
            if (x == n && y == m) return true;
            vis[x][y] = 1;
            q.push({ dis + 1, {x, y} });
        }
    }
    return false;
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= m; ++j) scanf("%d", &mp[i][j]);
        if (!mp[1][1]) { puts("impossible"); continue; }
        if (m + n == 2) {printf("%d
", mp[1][1]); continue; }
        int r = mp[1][1], l = 0;
        while (l < r)
        {
            int mid = (l + r + 1) >> 1;
            if (check(mid)) l = mid;
            else r = mid - 1;
        }
        if (!l) puts("impossible");
        else printf("%d
", l);
    }
    return 0;
}

　　

 K

（太菜了，花里胡哨的想，拆了绝对值，就是搜索）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N = 5e5 + 5;

int dist[N], t[N], h[N], k, n;

int main() 
{
    scanf("%d", &k);
    for (int cas = 1; cas <= k; ++cas)
    {
        scanf("%d", &n);
        map<int, vector<int> > g1, g2;
        map<int, bool> st1, st2;
        for(int i=1;i<=n;i++) scanf("%d", t + i);
        for(int i=1;i<=n;i++) scanf("%d", h + i);
        for(int i=1;i<=n;i++) 
        {
            g1[t[i] + h[i]].push_back(i);
            g2[t[i] - h[i]].push_back(i);
        }
        memset(dist, -1, sizeof dist);
        dist[1] = 0;
        queue<int> que;
        que.push(1);
        while (que.size()) 
        {
            int node = que.front(); que.pop();
            if(!st1[t[node] + h[node]]) 
            {
                st1[t[node] + h[node]] = 1;
                for(auto &new_node : g1[t[node] + h[node]])
                    if(dist[new_node] == -1)
                        dist[new_node] = dist[node] + 1, que.push(new_node);
            }
            if(!st2[t[node] - h[node]]) 
            {
                st2[t[node] - h[node]] = 1;
                for(auto &new_node : g2[t[node] - h[node]])
                    if(dist[new_node] == -1)
                        dist[new_node] = dist[node] + 1, que.push(new_node);
            }
        }
        printf("Field #%d: %d

", cas, dist[n]);
    }
    return 0;
}