ZOJ Monthly, January 2019

A: Little Sub and Pascal's Triangle

Solved.

题意：

求杨辉三角第n行奇数个数

思路：

薛聚聚说找规律，16说Lucas

答案是 $2^p ;;p 为 n - 1 中 以2进制表示下1的个数$

证明

$Ans = sumlimits_0^n C_n^i ;\%; 2 = sumlimits_0^n C_{frac{n}{2}}^{frac{i}{2}} cdot C_{n;\%;2}^{i;\%;2}$

我们考虑 $C_{n ;\%; 2}^{i ;\%; 2}$ 一共有四种取值

$C_0^0 ;; C_0^1;; C_1^0 ;; C_1^1$

我们发现 只有 $C_0^1的值为0 其他三个值都为1$

那么我们再考虑$C_n^i 这个式子$

它通过卢卡斯定理分解 实际上可以写成

我们先假设 

$i 以二进制表示为$

$a_1, a_2, cdots a_k$

$n 以二进制表示为$

$b_1, b_2, cdots b_k$

那么 $C_n^i = C_{b_1}^{a_1} cdot C_{b_2}^{a_2} cdots C_{b_k}^{a_k}$

那么我们发现，

要满足$C_n^i;\%; 2 = 1 ;;$

$那么在b_y = 1的位置上，i在对应位置上取0或者1都可以$

在$b_y = 0 的位置上，i在对应位置的取值已经固定 是 0$

那么$i的取值一共有2^p  p 为(n - 1)以2进制表示下1的个数$

为什么是$n - 1 ;;因为杨辉三角是从第0行开始的$

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

ll n;

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%lld", &n);
        n--;
        ll tmp = 0;
        while(n)
        {
            if(n & 1) tmp++;
            n >>= 1;
        }
        ll ans = 1ll << tmp;
        printf("%lld
", ans);
    }
    return 0;
}

B:Little Sub and his Geometry Problem

Solved.

题意：

一个点的权值定义为它到左下角所有点的曼哈顿距离

q次查询， 每次查询权值为c的点的个数

思路：

$给出的点沿着x轴正方向， y轴正方向都是严格单调递增的。$

$因此可以枚举x轴， 动态维护左下角点个数以及权值， 向右走的同时$

$将横坐标相同， 纵坐标<=当前位置的点假如， 向下走的时候将纵坐标相同给的点移除$

$当前权值为c时 ans++$

(薛聚聚：不会写题解啊)

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const double eps = 1e-8;
const ll MOD = 1e9 + 7;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 10;

int n, k;
ll sum, cnt;
ll sum_arr[maxn], cnt_arr[maxn];
ll ans[20];

struct node {
    int x, y;
    node() {}
    node(int x, int y) :x(x), y(y) {}
    bool operator < (const node &other) const
    {
        return x == other.x ? y < other.y : x < other.x;
    }
}P[maxn];

ll solve(ll c)
{
    cnt = sum = 0;
    memset(sum_arr, 0, sizeof sum_arr);
    memset(cnt_arr, 0, sizeof cnt_arr);
    int index = 1;
    int ans = 0;
    int y = n;
    for (int x = 1; x <= n; ++x)
    {
        while (index <= k && P[index].x <= x)
        {
            if (P[index].y <= y)
            {
                cnt++;
                sum += P[index].x + P[index].y;
                sum_arr[P[index].y] += P[index].x + P[index].y;
                cnt_arr[P[index].y]++;
            }
            ++index;
        }
        while ((x + y) * cnt - sum > c)
        {
            sum -= sum_arr[y];
            cnt -= cnt_arr[y];
            --y;
        }
        if ((x + y) * cnt - sum == c) ++ans;
    }
    return ans;
}

void RUN()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d %d", &n, &k);
        for (int i = 1; i <= k; ++i) scanf("%d %d", &P[i].x, &P[i].y);
        sort(P + 1, P + 1 + k);
        int q;
        scanf("%d", &q);
        for (int i = 1; i <= q; ++i)
        {
            ll c;
            scanf("%lld
", &c);
            ans[i] = solve(c);
        }
        for (int i = 1; i <= q; ++i) printf("%lld%c", ans[i], " 
"[i == q]);
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}

E:Little Sub and Mr.Potato's Math Problem

Solved.

题意：

给出n， k

将n个数按照字典序排序， k所在的位置为m

现在给出k， m  求最小的n

思路：

当k为10的整数倍， 那么它一定在第$log_{10^k}$

$随后统计当n=k的时候， 排在k前面的个数，和m比较， 判断是否合法$

$接着不断增加n， 统计每次增长排在k前面的个数， 随后输出n$

(薛聚聚：不会写题解啊)

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const double eps = 1e-8;
const ll MOD = 1e9 + 7;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 10;

ll k, m;
int arr[maxn];
ll pow_10[10];

void Init()
{
    pow_10[0] = 1;
    for (int i = 1; i <= 18; ++i)
    {
        pow_10[i] = pow_10[i - 1] * 10;
    }
}

void solve()
{
    ll num = 1;
    for (int i = 1;; ++i)
    {
        if (num > k) break;
        else if (num == k)
        {
            if (i == m)
            {
                printf("%lld
", k);
                return;
            }
            else
            {
                puts("0");
                return;
            }
        }
        num *= 10;
    }
    int len = 0;
    num = k;
    while (num)
    {
        arr[++len] = num % 10;
        num /= 10;
    }
    reverse(arr + 1, arr + 1 + len);
    ll ans = 0;
    num = 0;
    for (int i = 1; i <= len; ++i)
    {
        num = num * 10 + arr[i];
        ans += num - pow_10[i - 1];
        if (i != len) ++ans;
    }
    if (ans >= m)
    {
        puts("0");
        return;
    }
    else if (ans == m - 1)
    {
        printf("%lld
", k);
        return;
    }
    while (1)
    {
        len++;
        num *= 10;
        if (ans + num - pow_10[len - 1] >= m - 1)
        {
            ans = pow_10[len - 1] + m - ans - 2;
            printf("%lld
", ans);
            return;
        }
        ans += num - pow_10[len - 1];
    }
}

void RUN()
{
    Init();
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld %lld", &k, &m);
        solve();
    }
}

int main()
{
#ifdef LOCAL_JUDGE
    freopen("Text.txt", "r", stdin);
#endif // LOCAL_JUDGE

    RUN();

#ifdef LOCAL_JUDGE
    fclose(stdin);
#endif // LOCAL_JUDGE
    return 0;
}

F:Little Sub and a Game

Unsolved.

题意：

有两个玩家$A, B 刚开始有一个变量v = 0$

$A玩家有N个pair, B玩家有M个pair ;; pair 为(x, y) A玩家N次操作，每次选择x_i 或者 y_i 来异或v B玩家有M次操作$

$A玩家先进行N次操作, B玩家再进行M次操作$

A玩家想让$v尽量大，B玩家想让v尽量小$

两个玩家都采用最优策略，求最后$v$的值

G:Little Sub and Tree

Solved.

题意：

给出一个无根树，选取$k个点对所有点进行编码$

按如下方式进行编码

$令选取的k个点为 s_1, s_2 cdots s_k$

编出的码有$k位$

$对于u来说，第i位的编码为 s_i -> u的简单路径上的点的总数$

思路：

如果是一条链的话  那么取两端的一个就可以了

那么我们考虑一棵树中，如果某个节点的儿子对应的子树是一条链

那么这条链是可以被缩点成一个叶节点 而对答案没有影响

那么现在树就被我们简化成了 只有叶节点的子树

首先注意到，一棵子树内节点的区分和这棵子树外的点的选取是没有关系的

那么我们考虑 一个点对应的儿子当中，如果有$x个叶节点$

那么这x个节点要想被区分，就需要取$x - 1$ 个

再考虑一个点的儿子对应的子树，如果子树内都被区分了，那么合并起来也是被区分的

那么考虑选谁作为根

只要根不在链上就可以了，因为如果在链上会对缩点产生影响

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

#define N 100010
int t, n, root, d[N], fa[N];
vector <int> G1[N], G2[N], res;

int pre(int u)
{
    int id = -1;
    int cnt = G1[u].size() - 1;
    if (cnt == 0) return u;
    for (auto v : G1[u]) if (v != fa[u])    
    {
        fa[v] = u; 
        id = pre(v);
        G2[u].push_back(id);
    }
    if (cnt == 1 && u != root) return id;
    else return u;
}

void DFS(int u)
{
    int need = 0;
    for (auto v : G2[u]) if (v != fa[u] && !d[v])
        ++need;
    --need;
    for (auto v : G2[u]) if (v != fa[u])
    {
        fa[v] = u;
        if (!d[v] && need > 0)
        {
            --need;
            res.push_back(v);
        }
        DFS(v);
    }
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) 
        {
            G1[i].clear();
            G2[i].clear();
            d[i] = -1;
            fa[i] = 0;
        }
        res.clear();
        root = -1;

        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G1[u].push_back(v);
            G1[v].push_back(u);
            ++d[u]; ++d[v];
        }
        if (n == 2)
        {
            puts("1
1");
            continue;
        }
        for (int i = 1; i <= n; ++i) if (d[i] > 1)
        {
            root = i;
            break;
        }
        if(root == -1)
        {
            int ans = 0;
            for(int i = 1; i <= n; ++i) if(d[i] == 0) ans = i;
            printf("1
%d
", ans);
            continue;
        }
        pre(root);
        DFS(root);
        //puts("bug");
        //for (int i = 1; i <= n; ++i) printf("%d %d
", i, fa[i]);
        //puts("bug");
        int k = res.size();
        printf("%d
", k);
        for (int i = 0; i < k; ++i) printf("%d%c", res[i], " 
"[i == k - 1]);
    }
    return 0;
}

I:Little Sub and Isomorphism Sequences

Solved.

题意：

有一个$A[], 两种操作$

• $A_x -> y$
• 查询最长同构子串

思路：

考虑最长同构子串肯定会有重叠部分，那么两端出去的部分就是不同的部分

那么这个不同的部分让它长度为1即可，因为多余的长度是没有用的

那么题意就可以转化为 找一个最长的子串，使得两端相同即可

将数据离散化 开2e5个set维护每个数的位置

然后用数据结构 维护答案的最大值 即可

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

#define N 200010
int t, n, m, a[N], b[N];
struct qnode
{
    int op, x, y;
    void scan()
    {
        scanf("%d", &op);
        if (op == 1) 
        {
            scanf("%d%d", &x, &y);
            b[++b[0]] = y;
        }
    }
}q[N];
set <int> s[N];
namespace SEG
{
    int a[N << 2];
    void build(int id, int l, int r)
    {
        a[id] = -1;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void update(int id, int l, int r, int pos, int v)
    {
        if (l == r)
        {
            a[id] = v;
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, v);
        else update(id << 1 | 1, mid + 1, r, pos, v);
        a[id] = max(a[id << 1], a[id << 1 | 1]);
    }
}
void Hash()
{
    sort(b + 1, b + 1 + b[0]);
    b[0] = unique(b + 1, b + 1 + b[0]) - b - 1;
    for (int i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + 1 + b[0], a[i]) - b;
    for (int i = 1; i <= m; ++i) if (q[i].op == 1) q[i].y = lower_bound(b + 1, b + 1 + b[0], q[i].y) - b;
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        SEG::build(1, 1, n + m);
        for (int i = 1; i <= n + m; ++i) s[i].clear(); b[0] = 0;
        for (int i = 1; i <= n; ++i) scanf("%d", a + i), b[++b[0]] = a[i];
        for (int i = 1; i <= m; ++i) q[i].scan(); Hash();
        for (int i = 1; i <= n; ++i) s[a[i]].insert(i);
        for (int i = 1; i <= n + m; ++i) if (s[i].size() >= 2)
            SEG::update(1, 1, n + m, i, *s[i].rbegin() - *s[i].begin());
        for (int i = 1; i <= m; ++i)
        {
            if (q[i].op == 1)
            {
                int v = a[q[i].x], x = q[i].x, y = q[i].y; 
                s[v].erase(x);
                SEG::update(1, 1, n + m, v, s[v].size() >= 2 ? *s[v].rbegin() - *s[v].begin() : -1);
                a[q[i].x] = y;
                v = y;
                s[v].insert(x);
                SEG::update(1, 1, n + m, v, s[v].size() >= 2 ? *s[v].rbegin() - *s[v].begin() : -1);
            }
            else printf("%d
", SEG::a[1]);
        }
    }
    return 0;
}