2019牛客多校第二场

D题

题目：给出一个无向图，求val第k小的最小团(团：完全子图，团中任意两点都有一条边相连）（val的计算  （i属于团）

ps: 听他们都说是状压dp，表示实在不会，找了一个大佬写的广搜觉得很好

首先最小的团是空团，然后再此基础上往里添加点，用优先队列维护val值即可

还有这里存边用的是 bitset 来优化，大幅度节省时间，位运算还是炒鸡流批的

/*
最小的团是空的完全图，然后加入点
广度优先搜索
*/
#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
struct node
{
    int id;
    ll w;
    bitset<105>cc;
    friend bool operator<(const node& a,const node& b)
    {
        return a.w > b.w;
    }
};
priority_queue<node>q;
bitset<105>s[105];
ll a[105];
int n,k;
string ss;
ll ans;

int main()
{
    scanf("%d%d",&n,&k);
    for(int i = 1;i <= n; ++i) scanf("%lld",&a[i]);
    for(int i = 1;i <= n; ++i)
    {
        cin>>ss;
        for(int j = 1;j <= n; ++j)
            s[i][j] = ss[j - 1] - '0';
    }
    ans = -1;
    node st;
    st.id = st.w = 0;
    q.push(st);
    while(!q.empty())
    {
        node now = q.top();
        q.pop();
        if(!--k)
        {
            ans = now.w;
            break;
        }
        for(int i = now.id + 1;i <= n; ++i)
        {
            if((now.cc & s[i]) == now.cc)   //第i个点与当前团中的所有点都相连
            {
                node next = now;
                next.w += a[i];
                next.cc[i] = 1;
                next.id = i;
                q.push(next);
            }
        }
    }
    printf("%lld\n",ans);
    return 0;
}

 

F题

题目：有2 * n个人，要求分成2组，每组n个人使价值最大

（价值：任意两个不在同一组的人之间的价值之和）

这道题暴力搜就好啦，当时不敢写搜索，但又不知道该怎么分配成两组555

注意的是我们不是在分完组后计算的价值，而是加入一个人就把这个人和其他人的价值加进去，把求价值的复杂度由 n^2 优化成 O(n)

#include<iostream>
#include<cstdio>
using namespace std;
 
typedef long long ll;
ll arr[30][30],aa[30],bb[30];
ll ans,sum;
int n;
 
void dfs(int a,int b)
{
    if(a == n && b == n)
    {
        ans = max(ans,sum);
        return;
    }
    if(a < n)
    {
        ll k = 0;
        for(int i = 1;i <= b; ++i)
            k += arr[bb[i]][a + b + 1];
        aa[a + 1] = a + b + 1;
        sum += k;
        dfs(a + 1,b);
        sum -= k;
    }
    if(b < n)
    {
        ll k = 0;
        for(int i = 1;i <= a; ++i)
            k += arr[aa[i]][a + b + 1];
        sum += k;
        bb[b + 1] = a + b + 1;
        dfs(a,b + 1);
        sum -= k;
    }
}
 
int main()
{
    scanf("%d",&n);
    for(int i = 1;i <= 2 * n; ++i)
        for(int j = 1;j <= 2 * n; ++j)
            scanf("%lld",&arr[i][j]);
    ans = -1;
    sum = 0;
    dfs(0,0);
    printf("%lld\n",ans);
    return 0;
}

 

H题

给出01矩阵，求第二大的全1子矩阵

单调栈的应用，最大全1子矩阵应该是很经典的问题啦，其中一个解法就是单调栈

换成第二大，只需把每次找到的长x和宽y ，把  x * y,(x - 1) * y,x * (y - 1) 存进优先队列从大到小排序，然后找第二个值即可

#include<bits/stdc++.h>
using namespace std;
 
int n,m,a[1010][1010];
priority_queue<int>q;
char ch;
 
int main()
{
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n; ++i)
        for(int j = 1;j <= m; ++j)
        {
            cin>>ch;
            if(ch != '0') a[i][j] = a[i - 1][j] + 1;
                else a[i][j] = 0;
        }
    q.push(0);
    q.push(0);
    for(int i = 1;i <= n; ++i)
    {
        stack<int>s;
        s.push(0);
        a[i][m + 1] = -1;
        for(int j = 1;j <= m + 1; ++j)
        {
            while(s.size() && a[i][s.top()] > a[i][j])
            {
                int t = s.top();
                s.pop();
                if(s.empty()) break;
                q.push((j - 1 - s.top()) * a[i][t]);
                q.push((j - 2 - s.top()) * a[i][t]);
                q.push((j - 1 - s.top()) * max(a[i][t] - 1,0));
            }
            s.push(j);
        }
    }
    q.pop();
    printf("%d\n",q.top());
    return 0;
}

J题

一个长度为1e9的序列，其值为1 或 -1，给出n个区间表示此区间内的数字是1，其余是-1，问有多少区间满足和大于0

参考大佬题解https://www.cnblogs.com/FST-stay-night/p/11218660.html

• 可能作为区间端点的点个数最多为3e7
• f[i]f[i]表示以第ii个区间右端点为答案右端点的最大区间和
• g[i]g[i]表示以第ii个区间左端点为答案左端点的最大区间和
• f[i]=max(0,f[i−1]−(l[i]−r[i−1]−1))+r[i]−l[i]+1
• g[i]=max(0,g[i+1]−(l[i+1]−r[i]−1))+r[i]−l[i]+1
• 如果f[i]+g[i+1]≥l[i+1]−r[i]−1，说明答案的左右端点可以跨越[r[i]+1,l[i+1]−1]，那么把这些合并考虑
• 搞完上面，问题就变成了给你一个长度不超过3e7的（1，−1）序列，问有多少区间和大于0
• 树状数组时间O(n∗logn)，稳T
• 考虑优化：
• 很好用的性质：每次查询与上次查询的差距等于1
• 从左到右枚举左端点，统计右边比当前值大的个数
• 加个标记，标记左移，稳

额，看起来好复杂是吧

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

const int INF = 0x3f3f3f3f;
const int maxn = 3e7 + 10,maxm = 1e6 + 10;

int l[maxm], r[maxm], f[maxm], g[maxm];
int sum[maxn], b[maxn], c[maxn];
int n;

int main() 
{
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d%d", &l[i], &r[i]);
    f[1] = r[1] - l[1] + 1;  //f[i]以i段右端点为结尾的能构造出的最大的前缀和
    for(int i = 2; i <= n; i++)
        f[i] = max(0, f[i - 1] - (l[i] - r[i - 1] - 1)) + r[i] - l[i] + 1;
    //0：以i-1段右端点结尾的能构造出的最大的前缀和都不足够跨过[i-1,i]之间的-1
    //f[i - 1] - (l[i] - r[i - 1] - 1)：跨过之后还剩下多少贡献给这段
    g[n] = r[n] - l[n] + 1;  //g[i]以i段左端点为开头的能构造出的最大的前缀和
    for(int i = n - 1; i >= 1; i--)
        g[i] = max(0, g[i + 1] - (l[i + 1] - r[i] - 1)) + r[i] - l[i] + 1;
    int i = 1, base = 10000000;
    ll ans = 0;
    while(i <= n) {
        int j = i + 1;
        while(j <= n && g[j] + f[j - 1] >= l[j] - r[j - 1] - 1) j++;
            //说明这个[j-1,j]之间的-1段可以因为两侧的f[j-1]和g[j]足够大而连接起来
        j--; //此时j是从i开始最远能够连接到的区间
        int left = max(0, l[i] - g[i]), right = min(1000000000 - 1, r[j] + f[j]);
        //left,right是至少会产生一个贡献的范围
        int t = i, mi = INF, mx = 0;
        sum[0] = 0;
        for(int k = left; k <= right; k++) { //统计这一整段可连接区间的前缀和
            if(k >= l[t] && k <= r[t])
                sum[k - left + 1] = sum[k - left] + 1;
            else
                sum[k - left + 1] = sum[k - left] - 1;
            if(k == r[t])
                t++;
            mi = min(mi, sum[k - left + 1] + base);
            mx = max(mx, sum[k - left + 1] + base); //b记录前缀和出现过的次数
            b[sum[k - left + 1] + base] ++;
        } //b记录前缀和出现过的次数的后缀和
        for(int k = mx - 1; k >= mi; k--)
            b[k] += b[k + 1]; //包含最左侧点的贡献
        ans += b[base + 1];
        for(int k = left; k <= right; k++) {
            t = sum[k - left + 1] + base;
            //t表示k位置sum的值
            //b[t+1]比t大的值的个数
            //c[t+1]比在k位置左侧的比t大的值的个数的lazy
            b[t + 1] -= c[t + 1]; //把lazy加上去
            c[t] += c[t + 1] + 1; //lazy标记下移
            c[t + 1] = 0; //清空lazy
            ans += b[t + 1];
        }
        for(int k = mi; k <= mx; k++)
            b[k] = 0, c[k] = 0;
        i = j + 1;
    }
    printf("%lld", ans);
    return 0;
}