CCPC-Wannafly Winter Camp Day7 (Div2, onsite)

Replay

---

Dup4：

• 啥都不会? 只能看着两位聚聚A题?

X:

• 模拟题不会写， 日常摔锅
• u， v分不清， 日常演员
• 又是自己没理清楚就抢键盘上机导致送了一万个罚时， 日常背锅 

A：迷宫

Solved.

考虑所有人从1号点排队出发，所有人都回到自己位置的时间

让深度大的先走，这样就不会产生堵塞

那么每个人的时间就是 在1号点的等待时间+深度

取最大值即可

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

#define N 100010
int n, a[N];
vector <int> G[N];

int deep[N], fa[N];
void DFS(int u)
{
    for (auto v : G[u]) if (v != fa[u])
    {
        deep[v] = deep[u] + 1;
        fa[v] = u;
        DFS(v);
    }
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) G[i].clear();
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        deep[1] = 0; DFS(1);
        vector <int> vec;
        for (int i = 1; i <= n; ++i) if (a[i]) vec.push_back(i);
        sort(vec.begin(), vec.end(), [](int a, int b) { return deep[a] > deep[b]; });
        int res = 0;
        int cnt = 0;
        for (auto it : vec)
        {
            res = max(res, cnt + deep[it]);
            ++cnt;
        }
        printf("%d
", res);
    }
    return 0;
}

C：斐波那契数列

Solved.

斐波那契数列$前n项和的通项是$

$Fib_n & (Fib_n - 1) = Fib_n - lowbit(Fib_n)$

$S_n = 2 cdot a_n + a_{n - 1} - 1$

打表找规律发现

后面那部分是

$1 1 2 1 1 8 1 1 2 1 1 16 1 1 2 1 1 8 1 1 2 1 1cdots$

有对称性，可以递归求和

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

#define ll long long
const ll MOD = (ll)998244353;

int t; ll R;
struct node
{
    ll a[2][2];
    node operator * (const node &other) const
    {
        node res; memset(res.a, 0, sizeof res.a);
        for (int i = 0; i < 2; ++i) 
            for (int j = 0; j < 2; ++j)
                for (int k = 0; k < 2; ++k)
                    res.a[i][j] = (res.a[i][j] + a[i][k] * other.a[k][j] % MOD + MOD) % MOD;
        return res;
    }
};

ll a[2][2] = 
{
    1, 1,
    1, 0,
};

ll b[2][2] = 
{
    1, 1,
    0, 0, 
};

node qpow(ll n)
{
    node base;
    for (int i = 0; i < 2; ++i) 
        for (int j = 0; j < 2; ++j)
            base.a[i][j] = a[i][j];
    node res;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2; ++j)
            res.a[i][j] = b[i][j];
    while (n)
    {
        if (n & 1) res = res * base;
        base = base * base;
        n >>= 1;
    }
    return res;
}

ll qpow(ll base, ll n)
{
    ll res = 1;
    while (n)
    {
        if (n & 1) res = (res * base) % MOD;
        base = (base * base) % MOD;
        n >>= 1;
    }
    return res;
}


ll pos[64], num[64], sum[64];
ll solve(ll now)
{
    if (now <= 0) return 0; 
    if (now == 1) return 1;
    if (now == 2) return 2;
    if (now == 3) return 4;
    if (now == 4) return 5;
    if (now == 5) return 6;
    int id = upper_bound(pos + 1, pos + 62, now) - pos - 1; 
    if (pos[id] == now) return (sum[id] + num[id]) % MOD; 
    return ((solve(now - pos[id]) + solve(pos[id])) % MOD);  
}

int main()
{
    pos[1] = 6;
    for (int i = 2; i <= 61; ++i) pos[i] = pos[i - 1] << 1; 
    num[1] = 8;
    for (int i = 2; i <= 61; ++i) num[i] = (num[i - 1] << 1) % MOD;
    sum[1] = 6;
    for (int i = 2; i <= 61; ++i) sum[i] = ((sum[i - 1] << 1) % MOD + num[i - 1]) % MOD;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld", &R);
        ll need = 0;
        if (R == 1) need = 1;
        else if (R == 2) need = 2;
        else if (R == 3) need = 4;
        else need = (2ll * qpow(R - 2).a[0][0] % MOD + qpow(R - 3).a[0][0] % MOD - 1 + MOD) % MOD;
        //cout << R << " " << need << " " << solve(R) << "
";
        printf("%lld
", (need - solve(R) % MOD + MOD) % MOD);  
    }
    return 0;
}

  

D：二次函数

Solved.

枚举哪两个式子相等，做三次

考虑二元一次方程的根，令$y相同，则有$

$x_1 = -frac{a_1 pm sqrt{4 cdot y + a_1^2 - 4 cdot b_1}}{2}$

$x_2 = -frac{a_2 pm sqrt{4 cdot y + a_2^2 - 4 cdot b_2}}{2}$

考虑根号下一定是一个平方数

那么令$T^2 = 4 cdot y + a_1^2 - 4 cdot b_1$

$t^2 = 4 cdot y + a_2^2 - 4 cdot b_2$

$T^2 - t^2 = (T + t) cdot (T - t) = a_1^2 - 4 cdot b_1 - a_2^2 + 4 cdot b_2$

$枚举差值的因数分解，得到T 和 t 再判断是否可以$

$再特判 差值为0 和 差值为1的情况$ 

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

#define ll long long
#define pll pair <ll, ll>
int t;
ll a[3], b[3];

pll res;
bool solve(ll a1, ll b1, ll a2, ll b2)
{
    ll t1 = (a1 * a1 - 4 * b1);
    ll t2 = (a2 * a2 - 4 * b2);
    ll gap = abs(t1 - t2);
    if (gap == 0)
    {
        if ((t1 & 1) == (t2 & 1))
        {
            res.first = 0;
            res.second = -(a2 - a1) / 2;
            return true;
        }
        else
            return false;
    }
    if (gap == 1)
    {
        if ((t1 & 1) != (t2 & 1))
        {
            if (t1 > t2 && ((a1 & 1) == 1))
            {
                res.first = -(a1 + 1) / 2;
                res.second = -a2 / 2;
                return true;
            }
            else if (t1 < t2 && ((a2 & 1) == 1))
            {
                res.first = -a1 / 2;
                res.second = -(a2 + 1) / 2;
                return true;
            }
            else return false;
        }
    }
    for (int i = 1; i * i < gap; ++i) if (gap % i == 0 && (i + gap / i) % 2 == 0)
    {
        ll T = (i + gap / i) / 2;
        ll t = (gap / i - i) / 2;
        if (t1 < t2) swap(T, t);
        if ((T + a1) % 2 == 0 && (t + a2) % 2 == 0)
        {
            res.first = -((T + a1) / 2);
            res.second = -((t + a2) / 2);
            return true;
        }
    }
    return false;
}

void work()
{
    for (int i = 0; i < 3; ++i)
        for (int j = i + 1; j < 3; ++j)
        {
            if (solve(a[i], b[i], a[j], b[j]))
            {
                if (i == 0)
                {
                    printf("%lld %lld %lld
", res.first, j == 1 ? res.second : 0, j == 1 ? 0 : res.second);
                }
                else
                    printf("0 %lld %lld
", res.first, res.second);
                return;
            }
        }
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        for (int i = 0; i < 3; ++i) scanf("%lld%lld", a + i, b + i);
        work();    
    }
    return 0;
}

E：线性探查法

Solved.

拓扑排序?

#include<bits/stdc++.h>

using namespace std;

const int MAXN = 1e6 + 10;
const int maxn = 1e3 + 10;

struct Edge{
    int to, nxt;
    Edge(){}
    Edge(int to, int nxt): to(to), nxt(nxt){}
}edge[MAXN << 1];

struct node{
    int val;
    int index;
    node(){}
    node(int val, int index):val(val), index(index){}
    bool operator < (const node &other) const{
        return val > other.val;
    }
}brr[maxn];

int n;
int arr[maxn];
int head[maxn], tot;
int du[maxn];

void Init()
{
    tot = 0;
    memset(head, -1, sizeof head);
    memset(du, 0, sizeof du);
}

void addedge(int u,int v)
{
    edge[tot] = Edge(v, head[u]); head[u] = tot++;
}

void solve()
{
    priority_queue<node>q;
    for(int i = 0; i < n; ++i) if(du[i] == 0)
    {
        q.push(brr[i]);
    }
    int tot = 1;
    while(!q.empty())
    {
        node st = q.top();
        q.pop();
        arr[tot++] = st.val;
        int u = st.index;
        for(int i = head[u]; ~i; i = edge[i].nxt)
        {
            int v = edge[i].to;
            --du[v];
            if(du[v] == 0) q.push(brr[v]);
        }
    }
}

int main()
{
    while(~scanf("%d" ,&n))
    {
        Init();
        for(int i = 0; i < n; ++i)
        {
            int x;
            scanf("%d", &x);
            int now = i;
            int pre = x % n;
            brr[i] = node(x, i);
            while(now != pre)
            {
                now = (now - 1 + n) % n;
                addedge(now, i);
                du[i]++;
            }
        }
        solve();
        for(int i = 1; i <= n; ++i) printf("%d%c", arr[i], " 
"[i == n]);
    }    
    return 0;
}

F：逆序对!

Solved.

考虑两个位置的数对有多少个数异或会让他们对答案产生贡献

如果$a > b 那么从高位到地位找到第一位不同的数 这一位要放0，其他位任意的比m小的数$

$a < b 同理$

复杂度$O(n^2logn)$

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

#define ll long long
#define N 1010
const ll MOD = (ll)998244353;
ll Bit[35], res;
int n, m, b[N];

void solve(ll a, ll b)
{
    for (int i = 31; i >= 0; --i)
    {
        int n1 = ((a >> i) & 1), n2 = ((b >> i) & 1);
        if (n1 != n2)
        {
            ll tmp1 = m >> (i + 1);
            ll tmp2 = m & (Bit[i] - 1);
            ll sum = 0;
            if((m >> i) & 1)
                sum = (tmp1 * Bit[i] % MOD + tmp2 + 1) % MOD; 
            else
                sum = (tmp1 * Bit[i]) % MOD;
            if (a < b) res = (res + sum) % MOD;
            else res = (res + m - sum + MOD) % MOD;
            return ;
        }
    }
}

int main()
{
    Bit[0] = 1;
    for (int i = 1; i <= 32; ++i) Bit[i] = (Bit[i - 1] << 1);
    while (scanf("%d%d", &n, &m) != EOF)
    {
        res = 0;
        for (int i = 1; i <= n; ++i) scanf("%d", b + i); 
        for (int i = 1; i <= n; ++i) for (int j = i + 1; j <= n; ++j)
            solve(b[i], b[j]);
        printf("%lld
", res);
    }
    return 0;
}

G：抢红包机器人

Solved.

至少存在一个机器人，枚举这一位机器人

那么它前面所有账号都是机器人，并且这种关系是传递的，DFS即可

u, v 傻傻分不清楚可还行

#include<bits/stdc++.h>

using namespace std;

const int INF = 0x3f3f3f3f;

const int MAXN = 1e6 + 10;
const int maxn = 1e2 + 10;

struct Edge{
    int to, nxt;
    Edge(){}
    Edge(int to, int nxt):to(to), nxt(nxt){}
}edge[MAXN << 1];

int n, m;
int head[maxn], tot;
int vis[maxn];
int arr[maxn];

void Init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}

void addedge(int u,int v)
{
    edge[tot] = Edge(v, head[u]); head[u] = tot++;
}

void DFS(int u)
{
    for(int i = head[u]; ~i; i = edge[i].nxt)
    {
        int v = edge[i].to;
        if(vis[v]) continue;
        vis[v] = 1;
        DFS(v);
    }
}

int main()
{
    while(~scanf("%d %d", &n, &m))
    {
        Init();
        for(int i = 1, k; i <= m; ++i)
        {
            scanf("%d", &k);
            for(int j = 1; j <= k; ++j)
            {
                scanf("%d", arr + j);
            }
            for(int u = k; u >= 1; --u)
            {
                for(int v = u - 1; v >= 1; --v)
                {
                    addedge(arr[u], arr[v]);
                }
            }
        }
        int ans = INF;
        for(int i = 1; i <= n; ++i)
        {
            memset(vis, 0, sizeof vis);
            vis[i] = 1;
            DFS(i);
            int sum = 0;
            for(int j = 1; j <= n; ++j) sum += vis[j];
            ans = min(ans, sum);
        }
        printf("%d
", ans);
    }
    return 0;
}

J：强壮的排列

Solved.

打了个表？ Comet OJ 支持512Kb  感人