2017 ACM/ICPC Asia Regional Qingdao Online Solution

A : Apple

题意：给出三个点，以及另一个点，求最后一个点是否在三个点的外接圆里面，如果在或者在边界上，输出“Rejected”，否则输出"Accepted"

思路：先求一个外接圆，得到圆心和半径，再判一下，注意精度问题，用JAVA

import java.math.BigDecimal;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for(int cas = 1; cas <= t; ++cas)
        {
            BigDecimal x1 = in.nextBigDecimal();
            BigDecimal y1 = in.nextBigDecimal();
            BigDecimal x2 = in.nextBigDecimal();
            BigDecimal y2 = in.nextBigDecimal();
            BigDecimal x3 = in.nextBigDecimal();
            BigDecimal y3 = in.nextBigDecimal();
            BigDecimal x = in.nextBigDecimal();
            BigDecimal y = in.nextBigDecimal();
            //x
            BigDecimal temp1 = y2.subtract(y1);
            BigDecimal temp2 = y3.multiply(y3).subtract(y1.multiply(y1)).add(x3.multiply(x3)).subtract(x1.multiply(x1));
            BigDecimal temp3 = y3.subtract(y1);
            BigDecimal temp4 = y2.multiply(y2).subtract(y1.multiply(y1)).add(x2.multiply(x2)).subtract(x1.multiply(x1));
            temp1 = temp1.multiply(temp2);
            temp3 = temp3.multiply(temp4);
            BigDecimal x0 = temp1.subtract(temp3);
            temp1 = x3.subtract(x1).multiply(y2.subtract(y1)).subtract(x2.subtract(x1).multiply(y3.subtract(y1)));
            temp1 = temp1.multiply(BigDecimal.valueOf(2.0));
            x0 = x0.divide(temp1);
            //y
            temp1 = x2.subtract(x1);
            temp2 = x3.multiply(x3).subtract(x1.multiply(x1)).add(y3.multiply(y3)).subtract(y1.multiply(y1));
            temp3 = x3.subtract(y1);
            temp4 = x2.multiply(x2).subtract(y1.multiply(y1)).add(y2.multiply(y2)).subtract(y1.multiply(y1));
            temp1 = temp1.multiply(temp2);
            temp3 = temp3.multiply(temp4);
            BigDecimal y0 = temp1.subtract(temp3);
            temp1 = y3.subtract(y1).multiply(y2.subtract(y1)).subtract(y2.subtract(y1).multiply(x3.subtract(x1)));
            temp1 = temp1.multiply(BigDecimal.valueOf(2.0));
            y0 = y0.divide(temp1);
            //r
            temp1 = x1.subtract(x0);
            temp2 = y1.subtract(y0);
            temp1 = temp1.multiply(temp1);
            temp2 = temp2.multiply(temp2);
            BigDecimal r = temp1.add(temp2);
            //dis
            temp1 = x.subtract(x0);
            temp2 = y.subtract(y0);
            temp1 = temp1.multiply(temp1);
            temp2 = temp2.multiply(temp2);
            BigDecimal dis = temp1.add(temp2);
            if(dis.compareTo(r) > 0)
            {
                System.out.println("Accepted");
            }
            else
            {
                System.out.println("Rejected");
            }
        }
    }
}
//3
//-2 0 0 -2 2 0 2 -2
//-2 0 0 -2 2 0 0 2
//-2 0 0 -2 2 0 1 1

 

B：Bomberman

留坑。

 

C：The Dominator of Strings

题意：给出N个串，然后找出这N个串中是否有一个串包含其他所有串，如果有，输出那个串，如果没有，输出 No

思路：显然，如果答案存在，那么必定是长度最大的那个串。本来想着用KMP, 然后没想到用.find() 就可以过了。

#include <bits/stdc++.h>

using namespace std;

#define N 100010

string s[N], T;

int t, n;

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin >> t;
    while (t--)
    {
        cin >> n;
        int Max = 0, pos;
        for (int i = 1; i <= n; ++i)
        {
            cin >> s[i];
            if (s[i].length() > Max)
            {
                Max = s[i].length();
                pos = i;
            }    
        }
        int cnt = 0;
        for (int i = 1; i <= n; ++i)
        {
            if (i == pos) continue;
            if (s[pos].find(s[i]) != s[pos].npos)
                cnt++;
        }
        if (cnt == n - 1)
            cout << s[pos] << endl;
        else cout << "No\n";
    }
    return 0;
}

 KMP：

// KMP 版本， 比.find() 还慢。。
#include <bits/stdc++.h>

using namespace std;

#define N 100010

int t, n;

int Next[N];

inline void pre(string x, int m)
{
    int i, j;
    j = Next[0] = -1;
    i = 0;
    while (i < m)
    {
        while (-1 != j && x[i] != x[j]) j = Next[j];
        if (x[++i] == x[++j]) Next[i] = Next[j];
        else Next[i] = j;
    }
}

inline bool KMP(string x, int m, string y, int n)
{
    int i, j;
    pre(x, m);
    i = j = 0;
    while (i < n)
    {
        while (-1 != j && y[i] != x[j]) j = Next[j];
        i++, j++;
        if (j >= m)
        {
            return true;
        }
    }
    return false;
}

string s[N];

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin >> t;
    while (t--)
    {
        cin >> n;
        int Max = 0, pos;
        for (int i = 1; i <= n; ++i)
        {
            cin >> s[i];
            if (s[i].length() > Max)
            {
                Max = s[i].length();
                pos = i;
            }        
        }
        int cnt = 0, len = s[pos].length();
        for (int i = 1; i <= n; ++i)
        {
            if (i == pos) continue;
            if (KMP(s[i], s[i].length(), s[pos], len))
                cnt++;
            else
                break;
        }
        if (cnt == n - 1)
            cout << s[pos] << "\n";
        else
            cout << "No\n";
    }    
}

 

D：The Intersection

题意：给出两个函数，用一个有理分数去逼近两函数交点的横坐标，有理分数的分母小于1e5

思路：考虑二分

分数的二分可以用一个结论

a/b < (a + c) / (b + d) < c / d

然后考虑 k = k² 那么x³ = k 那么 先去逼近k  (x - 1)³ < k <= x³   如果x³ == k  直接输出 x / 1

反之 令 l = (x - 1) / 2  r = (x) / 2  进行二分

#include <bits/stdc++.h>

using namespace std;

#define ld long double
#define ll long long 

int t;

inline ll GCD(ll a, ll b) 
{
    while (b ^= a ^= b ^= a %= b);
        return a;
}

int main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(false);
    cin >> t;
    while (t--)
    {
        ll k;
        cin >> k;
        ld K = k * k;        
        ll x = 1;
        while (x * x * x < K) x++;
        if (x * x * x == K)
        {
            cout << x << "/1\n";
            continue;
        }
        ll a = 1, b = x - 1, c = 1, d = x;
        ll e, q, tar = K; 
        ld gap = x * x * x - tar;  
        while (true)
        {
            ll aa = a + c, bb = b + d;
            if (aa > 1e5) break; 
            ld tmp = (ld)bb * bb * bb / aa / aa / aa;
            if (fabsl(tmp - tar) < gap) 
            {
                gap = fabsl(tmp - tar);
                q = bb;
                e = aa;
            }
            if (tmp > tar)
            {
                d = bb, c = aa;
            }
            else
            {
                b = bb, a = aa;
            }
        }
        cout << q << "/" << e << "\n";
    }
    return 0;
}

 

 

E：King's Visit

留坑。

 

F：Pythagoras

题意：找到所有满足$x^2 + y^2 = z^2$ 的$(x, y, z)$   $(x, y, z) < 1e9$ 满足 $x <y < z 并且 (x, y, z) 互质$ 计算 $\sum {a_{y mod 2^k}}$

思路：毕达哥拉斯三元组

$x = a^2 - b^2$

$y = 2ab$

$z = a^2 + b^2$

z最大 ， x, y 大小不定 当 a, b 互质时，(x, y, z) 互质 并且 a > b

暴力枚举a, b  然后取模 (1 << 17)

计算的时候，假设 k = 2  那么 $x \equiv 1 \pmod k$ 相当于 $x \equiv 1 \pmod {1 << 17}$ $x \equiv 5 \pmod {1 << 17}$ ...

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

#define N 200010
#define MOD 131072
#define ll long long
#define INF 1000000000

int t, k, n;
int arr[N];
ll ans[N];
vector <int> fac[25000];

inline bool ok(int x, int y) 
{
    for (int i = 0, len = fac[y].size(); i < len; ++i)
        if (x % fac[y][i] == 0) return false;
    return true;
}

inline void Init()
{
    for (int i = 2; i * i <= (INF >> 1); i += 2)
        fac[i].emplace_back(2);
    int limit = sqrt(INF >> 1);  
    for (int i = 3; i <= limit; i += 2) 
    {
        if (fac[i].empty())  
            for (int j = i; j * j <= (INF >> 1); j += i)
                fac[j].emplace_back(i);
    }
    ll cnt = 0;
    for (int b = 1; b * b <= (INF >> 1); ++b)
    {
        for (int a = b + 1; a * a + b * b <= INF; a += 2)
        {
            if (ok(a, b)) 
                ++ans[max(2 * a * b, a * a - b * b) % MOD];
        }
    }
}

inline void Run()
{
    Init();
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &k); n = 1 << k;
        for (int i = 0; i < n; ++i) scanf("%d", arr + i);
        ll sum = 0;
        for (int i = 0; i < n; ++i)
            for (int j = 0; j * n + i < MOD; ++j)
                sum += (ll)arr[i] * ans[j * n + i];
        printf("%lld\n", sum);
    }
}


int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();

    return 0;
}

 

 

 

G：Zuma

题意：给出一个01串，若有三个相同的就可以消去，如果没有，可以发射若干个0或者若干个1使之消去，会有连锁反应，求最少的发射数

思路：我们可以先预处理一下，使得相同颜色的合并在一起。那么考虑 i, j  若第i个 与第j个 颜色相同

那么 dp[i][j] = dp[i + 1][j - 1] + max(3 - v[i] - v[j], 0) (v[] 表示这个合并后的区间内有多少个这种颜色)

还有一个区间dp通用转移方程 dp[i][j] = min(dp[i][j], dp[i][k], dp[k + 1][j])

还要考虑一个 如果 存在 i, j, k   若 v[i] + v[k] < 3 || v[k] + v[j] < 3

那么它们可能可以通过消去 区间[i + 1][k - 1] 和 [k + 1][j - 1] 来使得这三个产生连锁反应而有更优的答案

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

#define N 210

typedef pair <int, int> pii;

int t, cnt;
char s[N];
pii arr[N];
int dp[N][N];

inline void Run()
{
    scanf("%d", &t);
    for (int kase = 1; kase <= t; ++kase)
    {
        printf("Case #%d: ", kase);
        scanf("%s", s + 1);
        cnt = 0;
        for (int i = 1, len = strlen(s + 1); i <= len; ++i) 
        {
            int id = s[i] - '0';
            if (i == 1 || id != arr[cnt].second)
                arr[++cnt].first = 1, arr[cnt].second = id;
            else
                ++arr[cnt].first;
        }
        memset(dp, 0x3f, sizeof dp);
        for (int i = 1; i <= cnt; ++i) dp[i][i] = (arr[i].first == 2 ? 1 : 2);
        for (int i = 2; i <= cnt; ++i)
        {
            for (int j = 1; j + i - 1 <= cnt; ++j) 
            {
                int l = j, r = j + i - 1;
                if (arr[l].second == arr[r].second)
                    dp[l][r] = dp[l + 1][r - 1] + max(3 - arr[l].first - arr[r].first, 0); 
                for (int k = l; k < r; ++k)
                    dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + 1][r]);  
                if (arr[l].second == arr[r].second)
                    for (int k = l + 1; k < r; ++k) 
                    {
                        if (arr[l].second == arr[k].second && (arr[l].first + arr[k].first < 3 || arr[k].first + arr[r].first < 3))
                            dp[l][r] = min(dp[l][r], max(3 - arr[l].first - arr[k].first - arr[r].first, 0) + dp[l + 1][k - 1] + dp[k + 1][r - 1]); 
                    }
            }
        }
        printf("%d\n", dp[1][cnt]);
    }
}


int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();

    return 0;
}

 

 

H：Chinese Zodiac

按题意输出即可

#include <bits/stdc++.h>

using namespace std;

map <string, int> mp;

inline void Init()
{
    mp["rat"] = 1;
    mp["ox"] = 2;
    mp["tiger"] = 3;
    mp["rabbit"] = 4;
    mp["dragon"] = 5;
    mp["snake"] = 6;
    mp["horse"] = 7;
    mp["sheep"] = 8;
    mp["monkey"] = 9;
    mp["rooster"] = 10;
    mp["dog"] = 11;
    mp["pig"] = 12;
}

int t;

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    Init(); cin >> t;
    string a, b;
    while (t--)
    {
        cin >> a >> b;
        int ans = mp[b] - mp[a];
        if (ans < 1) ans += 12;
        cout << ans << endl;
    }
}

 

I：Smallest Minimum Cut

题意：给出一张图，然后给出两个点S, T, 要求选取一个含有最小边的一个边集，使得其流量为最大流

思路一： 可以将所有边权都乘以一个较大的数 + 1，那么本来边比较多的最大流，这样处理之后就不再是最大流，答案就是最大流%较大的数,因为这样处理之后，不会存在边数相同并且最大流相同的情况，可以分开考虑

因为最大流肯定是由若干个满流的容量组成，那么最后的最大流答案肯定是n * m + x  (m 为一个较大的数，x 为边数)

如果存在更少边使得组成最大流，那么最大流肯定是 n2 * m + x2 (易知x2 < x 那么显然n2 > n) 那么这个流肯定比上面那个大，那么这个才是答案，矛盾

如果存在更多边使得组成最大流，那么最大流肯定是n3 * m + x3 (显然 x3 > x 那么 n3 < n) 因为 m足够大，那么这个最大流肯定要小于上面那个最大流，这个不会是答案

思路二：跑一边网络流后，如果有一条路是满流的话，那么这条路可能为所求答案的其中一条路，将这条路的流量改为1，再将其他路的流量改成1e9，再跑一次网络流就可以得出所求答案。

 思路一：

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

const int maxn = 1e3 + 10;
const int INF = 0x3f3f3f3f;

int n, m;

struct Edge{
    int from;
    int to;
    int cap;
    int flow;
    inline Edge(){}
    inline Edge(int from,int to,int cap,int flow):from(from), to(to), cap(cap), flow(flow){}
};

vector<Edge>edge;
vector<int>G[maxn];
int vis[maxn];
int d[maxn];
int cur[maxn];
int S,T;

inline void init()
{
    edge.clear();
    for(int i = 1; i <= n; ++i)
        G[i].clear();
}

inline void addedge(int from,int to,int cap)
{
    edge.push_back(Edge(from,to,cap,0));
    edge.push_back(Edge(to,from,0,0));
    int len = edge.size();
    G[from].push_back(len - 2);
    G[to].push_back(len - 1);
}

inline bool bfs()
{
    memset(d,0,sizeof d);
    memset(vis,0,sizeof vis);
    queue<int>q;
    q.push(S);
    d[S] = 1;
    vis[S] = 1;
    while(!q.empty())
    {
        int x = q.front();
        q.pop();
        for(int i = 0; i < G[x].size(); ++i)
        {
            Edge &e = edge[G[x][i]];
            for(int i = 0; i < G[x].size(); ++i)
            {
                Edge &e = edge[G[x][i]];
                if(!vis[e.to] && e.cap > e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    q.push(e.to);
                }            
            }
        }
    }
    return vis[T];
}

inline int dfs(int x,int a)
{
    if(x == T || a == 0) return a;
    int flow = 0;
    int f;
    for(int &i = cur[x]; i < G[x].size(); ++i)
    {
        Edge &e = edge[G[x][i]];
        if(d[x] + 1 == d[e.to] && (f = dfs(e.to, min(a, e.cap- e.flow))) > 0)
        {
            e.flow += f;
            edge[G[x][i] ^ 1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}

inline int dicnic()
{
    int ans = 0;
    while(bfs())
    {
        memset(cur,0,sizeof cur);
        ans += dfs(S,INF);
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d %d",&n, &m);
        scanf("%d %d",&S, &T);
        for(int i = 1;i <= m; ++i)
        {
            int x, y, z;
            scanf("%d %d %d",&x, &y,&z);
            addedge(x,y,z * 999 + 1);
        }
        int ans = dicnic();
        printf("%d\n",ans % 999);
    }
    return 0;
}

 思路二：

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

const int maxn = 1e3 + 10;
const int INF = 0x3f3f3f3f;

int n, m;

struct Edge {
    int from;
    int to;
    int cap;
    int flow;
    inline Edge() {}
    inline Edge(int from, int to, int cap, int flow) :from(from), to(to), cap(cap), flow(flow) {}
};

vector<Edge>edge;
vector<int>G[maxn];
int vis[maxn];
int d[maxn];
int cur[maxn];
int S, T;

inline void init()
{
    edge.clear();
    for (int i = 1; i <= n; ++i)
        G[i].clear();
}

inline void addedge(int from, int to, int cap)
{
    edge.push_back(Edge(from, to, cap, 0));
    edge.push_back(Edge(to, from, 0, 0));
    int len = edge.size();
    G[from].push_back(len - 2);
    G[to].push_back(len - 1);
}

inline bool bfs()
{
    memset(d, 0, sizeof d);
    memset(vis, 0, sizeof vis);
    queue<int>q;
    q.push(S);
    d[S] = 1;
    vis[S] = 1;
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        for (int i = 0; i < G[x].size(); ++i)
        {
            Edge &e = edge[G[x][i]];
            for (int i = 0; i < G[x].size(); ++i)
            {
                Edge &e = edge[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    q.push(e.to);
                }
            }
        }
    }
    return vis[T];
}

inline int dfs(int x, int a)
{
    if (x == T || a == 0) return a;
    int flow = 0;
    int f;
    for (int &i = cur[x]; i < G[x].size(); ++i)
    {
        Edge &e = edge[G[x][i]];
        if (d[x] + 1 == d[e.to] && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edge[G[x][i] ^ 1].flow -= f;
            flow += f;
            a -= f;
            if (a == 0) break;
        }
    }
    return flow;
}

inline int dicnic()
{
    int ans = 0;
    while (bfs())
    {
        memset(cur, 0, sizeof cur);
        ans += dfs(S, INF);
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        init();
        scanf("%d %d", &n, &m);
        scanf("%d %d", &S, &T);
        for (int i = 1; i <= m; ++i)
        {
            int x, y, z;
            scanf("%d %d %d", &x, &y, &z);
            addedge(x, y, z);
        }
        int ans = dicnic();
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 0; j < G[i].size(); ++j)
            {
                int it = G[i][j];
                if (edge[it].cap == 0) continue;
                if (edge[it].flow == edge[it].cap)
                {
                    edge[it].cap = 1;
                    edge[it].flow = 0;
                }
                else
                {
                    edge[it].cap = INF;
                    edge[it].flow = 0;
                }
            }
        }
        ans = dicnic();
        printf("%d\n", ans);
    }
    return 0;
}

 

 

 

J：Brute Force Sorting

题意：给出N个数，如果arr[i] > arr[i + 1] 那么，这连个数都要删去，删若干轮后，直到不能删，输出最终的序列

思路：可以想到，如果在第一轮中，两个数被删去了，那么在下一轮可能被删去的数就有这两个数左边邻接的一个数，右边邻接的一个数，压入队列，继续判断。

因为每个数最多入队一次，最坏的时间复杂度O(n),

#include <bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f
#define N 100100

int t, n;
int arr[N];
int L[N], R[N], vis[N];

queue <int> q;

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin >> t;
    while (t--)
    {
        cin >> n; 
        for (int i = 1; i <= n; ++i)
        {
            cin >> arr[i];
            L[i] = i - 1, R[i] = i + 1; 
            vis[i] = 0; 
        }
        arr[0] = 0; arr[n + 1] = INF; 
        while (!q.empty()) q.pop();
        for (int i = 1; i <= n; ++i)
        {
            if (arr[i] < arr[i - 1] || arr[i] > arr[i + 1]) 
                q.emplace(i), vis[i] = 1;
        }    
        while (!q.empty())
        {
            int u = q.front(); q.pop();
            int l = L[u], r = R[u];
            R[l] = r, L[r] = l;
            if (l && r != n + 1 && !vis[r] && arr[l] > arr[r])
            {
                q.emplace(l); vis[l] = 1;
                q.emplace(r); vis[r] = 1;
            }
        }
        int cnt = 0;
        for (int i = 1; i <= n; ++i) if (!vis[i]) cnt++;
        cout << cnt << endl;
        for (int i = 1; i <= n; ++i) if (!vis[i])
            cout << arr[i] << " ";
        cout << "\n";
    }
}

 

 

K：A Cubic number and A cunbic Number

题意：给出一个素数p，判断它是不是能不能由两个不同的立方数相减得到

思路：假设p = a³ - b³ 那么根据立方差公式 p = (a - b)(a² + b² + ab)   显然 (a - b) < (a²  + b² + ab) 又p为素数 所以必然有一个为1，显然 (a - b) = 1

那么 p = (a² + b² + ab) 将a - b = 1 代入 有 p = 3a² + 3a + 1;

预处理一下即可

#include <bits/stdc++.h>

using namespace std;

#define ll long long

unordered_map <ll, bool> mp;

const ll D = (ll)1e12;

inline void Init()
{
    mp.clear();
    for (ll i = 1; true; ++i)
    {
        ll value = 3 * i * i + 3 * i + 1;
        if (value > D) break;
        mp[value] = true;
    }
}

int t;
ll p;

int main()
{
    Init();
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld", &p);
        puts(mp[p] ? "YES" : "NO");
    }
    return 0;
}

 

 

---

 

　赛后总结：

• 如果TLE了，要检查一下是否是数组开小
• 如果开了队列或栈，MLE了，检查一下是否是死循环，一直在入栈，入队
• 如果计算几何或者有浮点数精度问题的，要考虑JAVA BigDecimal
• 输出的时候一定要检查格式，末尾有没有空格
• 输出YES NO 的答案时，一定要检查大小写是否正确
• 有时候要考虑队列暴力，栈暴力，不要一提到暴力，想到的就是很暴的暴力
• 如果数论题给出数特别特殊，比如说素数，一定要考虑其性质，即它不能表示为两个数的乘积之和，1除外
• 如果出现自己认为思路正确却依然wrong answer的时候，可以考虑重新写以及思路错误两个方面，而不是一味在原来代码上更改。
• 如果模数是2的幂次，那么卡常数取模可以用&(2 ^ k - 1)
• 二分的题目不一定每次都是取中间值，可以考虑其他值