2021"MINIEYE杯"中超(4)补题

2021"MINIEYE杯"中超(4)

1002 Kanade Loves Maze Designing

本题点数n最多为2000，因此允许O(n²)的做法，我们用dfs来计算任意两点间的点的种类数即可得出答案。因本题数据量较小，所以无需快速幂优化，直接循环n次预处理出K ^ (j - 1)即可。

#include <bits/stdc++.h>

using namespace std;

const int N = 2010, MOD1 = 1e9 + 7, MOD2 = 1e9 + 9, K = 19560929;

int t;
int n;
int cnt[N];
int am[N][N];
int c[N];
int ans;
int md1[N], md2[N];
vector<int> v[N];

void cal1(int i, int &k)//计算答案
{
    for (int j = 1; j <= n; j ++ ) k = (1ll * k + 1ll * am[i][j] * md1[j - 1]) % MOD1;
}

void cal2(int i, int &k)//计算答案
{
    for (int j = 1; j <= n; j ++ ) k = (1ll * k + 1ll * am[i][j] * md2[j - 1]) % MOD2;
}

void init()//预处理数组
{
    md1[0] = md2[0] = 1;
    for (int i = 1; i < N; i ++ )
    {
        md1[i] = 1ll * md1[i - 1] * K % MOD1;
        md2[i] = 1ll * md2[i - 1] * K % MOD2; 
    }
}
//+-1法求[i, j]间点的种类数
void add(int k)//加操作
{
    if (!cnt[k]) ans ++ ;
    cnt[k] ++ ;
    return;
}

void del(int k)//遍历过后的删除操作
{
    if (cnt[k] == 1) ans -- ;
    cnt[k] -- ;
    return;
}

void dfs(int now, int to, int fr)//删除操作,now表示从now点开始搜,to表示当前点,fr表示来向防止重复搜
{
    add(c[to]);//加上此点的值
    am[now][to] = ans;//记录now到此点的结果
    for (auto t : v[to])
        if (t != fr)//防止重复搜索
            dfs(now, t, to);
    del(c[to]);
    
    return;
}

void solve()
{
    cin >> n;
    for (int i = 2, x; i <= n; i ++ )
    {
        cin >> x;
        v[i].push_back(x), v[x].push_back(i);
    }
    for (int i = 1; i <= n; i ++ ) cin >> c[i];
    
    for (int i = 1; i <= n; i ++ )
    {
        dfs(i, i, -1);//当前搜i点,因为i点是起点,所以来向标记为-1
        
        int ans1 = 0, ans2 = 0;
        cal1(i, ans1), cal2(i, ans2);
        
        cout << ans1 << ' ' << ans2 << endl;
    }
    
    //for (int i = 1; i <= n; i ++ ) for (int j = 1; j <= n; j ++ ) cout << am[i][j] << (j == n ? '
' : ' ');
    for (int i = 1; i <= n; i ++ ) v[i].clear();
}

int main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    init();//初始化
    cin >> t;
    while (t -- ) solve();
    
    return 0;
}

1007 Increasing Subsequence

首先思考朴素一点的做法，采用一般处理线性dp的思路。f[i]表示以a[i]结尾的极大子序列，接着考虑贡献，对于j (j < i)，只有[j, i]中间没有a[j] ~ a[i]的元素，那么f[j] 才对 f[i]有贡献。f[i]对答案有贡献当且仅当[i ~ n]中没有比a[i]大的元素，所以朴素一点的线性dp解法就有了。O(n²)的复杂度，考虑到n是1e5的级别，会t。

接着思考优化，处理区间[l, r]时，以m为终点将其分开，然后两边维护两个单调栈，左边单调栈元素值从小到大，下标从大到小，右边单调栈元素值从小到大，下标从小到大。接着考虑贡献，对于f[i] (i > mid)，我们找到左边第一个比f[i]小的值a[j]，因为右边也维护了一个单调栈，所以栈顶元素即满足要求，如果栈空那么就返回0。然后去找左边单调栈中第一个比a[j]大的值和最后一个比a[i]小的值，那么这个范围内都是对f[i]有贡献的。直接将这些dp值加上即可。为了方便计算，我们可以用一个vector储存左边区间的dp值前缀和，并且在维护单调栈的同时也维护这个前缀和dp的vector。

code

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;

const int P = 998244353;

int add(int a, int b) {a += b; return a < P ? a : a - P;}
int sub(int a, int b) {a -= b; return a < 0 ? a + P : a;}

const int N = 100001;

int a[N], dp[N];

void solve(int l, int r)
{
    if (l + 1 == r) return;
    
    int mid = (l + r) >> 1;
    solve(l, mid);//处理左边
    vector<int> pos(r - l);
    iota(pos.begin(), pos.end(), l);//递增赋值下标
    sort(pos.begin(), pos.end(), [&](int i, int j) { return a[i] < a[j]; });//按照值递增排序排序
    vector<int> ls, rs;
    vector<int> sum(1, 0);//初始化加入一个0,方便前缀和
    for (int i : pos)//pos是有序的,所以每个a[i]一定是比当前在栈中的值都要大
    {
        if (i < mid)
        {
            while (!ls.empty() && ls.back() < i)//在我左边而且值还比我小,一定没有贡献,删掉就行
                sum.pop_back(), ls.pop_back();
            ls.push_back(i);//将i加入左边序列的单调栈
            sum.push_back(add(sum.back(), dp[i]));//更新左边dp前缀和         
        }
        else 
        {
            while (!rs.empty() && rs.back() > i)//在我右边还比我小,一定没有贡献,同样删掉
                rs.pop_back();
            if (ls.empty()) continue;//如果左边是空的,没有可以继承过来的状态
            //id1是找到大于a[i]的第一个元素,由于dp前缀和中有一个0,所以偏移一下会到小于a[i]的最后一个元素
            int id1 = partition_point(ls.begin(), ls.end(), [&](int x) { return a[x] < a[i]; }) - ls.begin();
            //id2是找到大于a[rs.back()]的第一个元素
            int id2 = rs.empty() ? 0 : partition_point(ls.begin(), ls.end(), [&](int x) { return a[x] < a[rs.back()]; }) - ls.begin();
            //更新处于右边的dp数组
            dp[i] = add(dp[i], sub(sum[id1], sum[id2]));
            rs.push_back(i);
        }
    }
    solve(mid, r);//递归处理右边
}

int main(void) 
{
    int T; scanf("%d", &T);
    while (T--) 
    {
        int n; scanf("%d", &n);
        for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
        for (int i = 1, v = INT_MAX; i <= n; ++i)//处理dp数组
        {
            if (v > a[i])//左边最小的比当前的大,说明以a[i]结尾的有贡献
                dp[i] = 1;
            else //反之一定会成为其他序列的子序列,没有贡献
                dp[i] = 0;
            v = min(v, a[i]);
        }
        solve(1, n + 1);//左闭右开
        int ans = 0;
        for (int i = n, v = 0; i >= 1; --i)
        {
            if (v < a[i])
                ans = add(ans, dp[i]);
            v = max(v, a[i]);
        }
        printf("%d
", ans);
    }
    return 0;
}

1008 Lawn of the Dead

对于每个点，只有其左边或者上面可以到达，它才可以到达。对于每个地雷，那么它一定挡住了从左边到达的这条路，这时候我们只能考虑从上方到达，因此对于每个地雷[i, j]，我们考虑[i - 1, j + 1]这个点向右连续不可到达的区域，那么第i行的这些列的可达情况肯定和其是一致的。因此我们可以通过这种操作算出不可到达的数量，最后用总点数量减去不可到达的数量再减去地雷数得到的就是答案。涉及到区间查询和区间修改的操作，因此可以用线段树维护状态，另外，因为考虑第i行的时候，我们只需要考虑第i - 1行的状态，类比滚动数组的思想，我们只需要建两棵线段树即可完成上述操作。

code

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

const int N = 200010;

int n, m, k;
int t;
vector<int> mine[N];//存每行地雷下标
struct node
{
    int p, l, r, val, lmx;//lmx为区间左端点开始连续不可到达的长度
    int lazy;//懒标记
}tr[2][N * 4];//两棵树

void build(int x, int u, int l, int r)
{
    tr[x][u].l = l, tr[x][u].r = r, tr[x][u].lazy = -1;//初始化懒标记
    if (l == r)
    {
        tr[x][u].val = tr[x][u].lmx = 0;
        tr[x][u].lazy = -1;
        
        return;
    }
    
    int mid = l + r >> 1;
    build(x, u << 1, l, mid), build(x, u << 1 | 1, mid + 1, r);
    
    //pushup操作
    tr[x][u].val = tr[x][u << 1].val + tr[x][u << 1 | 1].val;
    tr[x][u].lmx = 0;
}

void pushdown(int x, int u)
{
    if (tr[x][u].lazy != -1)//打标记了
    {
        //处理左子树
        tr[x][u << 1].val = (tr[x][u << 1].r - tr[x][u << 1].l + 1) * tr[x][u].lazy;
        tr[x][u << 1].lmx = (tr[x][u << 1].r - tr[x][u << 1].l + 1) * tr[x][u].lazy;
        //处理右子树
        tr[x][u << 1 | 1].val = (tr[x][u << 1 | 1].r - tr[x][u << 1 | 1].l + 1) * tr[x][u].lazy;
        tr[x][u << 1 | 1].lmx = (tr[x][u << 1 | 1].r - tr[x][u << 1 | 1].l + 1) * tr[x][u].lazy;
        //传递懒标记
        tr[x][u << 1].lazy = tr[x][u].lazy;
        tr[x][u << 1 | 1].lazy = tr[x][u].lazy;
        //清除父节点懒标记
        tr[x][u].lazy = -1;
    }
}

void modify(int x, int u, int l, int r, int v)
{
    if (tr[x][u].l >= l && tr[x][u].r <= r)
    {
        tr[x][u].val = (tr[x][u].r - tr[x][u].l + 1) * v;
        tr[x][u].lmx = (tr[x][u].r - tr[x][u].l + 1) * v;
        tr[x][u].lazy = v;
        
        return;
    }
    
    pushdown(x, u);
    int mid = tr[x][u].l + tr[x][u].r >> 1;
    if (l <= mid) modify(x, u << 1, l, r, v);
    if (r > mid) modify(x, u << 1 | 1, l, r, v);
    //pushup操作
    tr[x][u].val = tr[x][u << 1].val + tr[x][u << 1 | 1].val;//维护val即区间不可到达的数量
    if (tr[x][u << 1].val == tr[x][u << 1].r - tr[x][u << 1].l + 1)//左子树区间全部不可到达
        tr[x][u].lmx = tr[x][u << 1].val + tr[x][u << 1 | 1].lmx;//那么等于左区间尺寸加右区间不可达
    else tr[x][u].lmx = tr[x][u << 1].lmx;//否则就直接等于左区间不可达
    
    return;
}

int query(int x, int u, int l, int r)
{
    if (tr[x][u].l == l && tr[x][u].r == r) return tr[x][u].lmx;//此区间完全包含查询区间
    
    pushdown(x, u);
    int mid = tr[x][u].l + tr[x][u].r >> 1;
    if (r <= mid) return query(x, u << 1, l, r);
    if (l > mid)  return query(x, u << 1 | 1, l, r);
    
    int temp = query(x, u << 1, l, mid);//查询左子树,左边全部到不了再查右子树
    if (temp == mid - l + 1) return temp + query(x, u << 1 | 1, mid + 1, r);
    else return temp;
}

int main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin >> t;
    while (t -- )
    {
        cin >> n >> m >> k;
        build(0, 1, 1, m), build(1, 1, 1, m);//建立两棵线段树
        for (int i = 0; i <= n + 10; i ++ ) mine[i].clear();//清空vector
        int x, y;
        for (int i = 1; i <= k; i ++ )
        {
            cin >> x >> y;
            mine[x].push_back(y);
        }    
        
        long long ans = 0;//储存不可到达的非地雷区域数目
        modify(0, 1, 1, m, 1);//处理第0行,懒标记为1表示不可到达
        for (int i = 1; i <= n; i ++ )//一行一行处理
        {
            sort(mine[i].begin(), mine[i].end());//将地雷按照纵坐标升序排列
            mine[i].push_back(m + 1);//保证最后一个区间一定有右端点,加一个哨兵
            int last = 0;//此行上一个雷的位置
            modify((i & 1), 1, 1, m, 0);//清空线段树
            
            for (int j = 0; j < mine[i].size(); j ++ )//遍历所有雷
            {
                int poi = mine[i][j];//雷的位置
                if (i == 1 && !last) {last = poi; continue;}//处理第一行
                int l = last + 1, r = poi - 1, len;//处理区间[l + 1, r - 1]
                if (l <= r)
                {
                    len = query((i & 1) ^ 1, 1, l, r);//查询上一行
                    ans += 1ll * len;
                }
                else len = 0;//否则此区间不存在不可到达的点
                if (!(l - 1 == 0 && l - 1 + len == 0)) modify((i & 1), 1, l - 1, l - 1 + len, 1);//标记左侧的地雷
                last = poi;//更新上一个地雷的位置
            }
        }
        
        cout << 1ll * n * m - ans - 1ll * k << endl;
    }
    
    return 0;
}