2022牛客多校#2

2022牛客多校#2

G Link with Monotonic Subsequence

题意：设排列的价值为其 “最长递增子序列” 和 “最长递减子序列” 的最大值。构造一个长为 n 且使 “最长递增子序列” 和 “最长递减子序列” 的最大值最小的序列
思路：直接计算出最小权值 ⌈ √ n ⌉ 分块倒着输出

#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

const int N = 2e6+10;

int a[N];

void solve(){
    int n;
    cin >> n;
    for (int i = 1 ;i <= n; i++) a[i] = i;
    int t = ceil(sqrt(n));
    for (int i = 1; i < n; i += t){
        int start = i, end = i+t;
        if (end > n+1) end = n+1;
        reverse(a+start, a+end);
    }
    for (int i = 1; i <= n; i++){
        if (i > 1) cout << ' ';
        cout << a[i];
    }
    cout << endl;
}

int main(){
    int t = 1;
    cin >> t;
    while (t--) solve();
    return 0;
}

K Link with Bracket Sequence I

思路：我们将左括号视作 1 ，右括号视作 -1 ，考虑 DP， f(i,j,k)表示考虑到第 i个点，匹配到了第 j 位，目前和为 k的方案数，转移分为匹配与不匹配两种情况考虑即可

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define fir first
#define sec second
int mread()
{
    int ret = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = -1;
        c = getchar();
    }
    do
    {
        ret = ret * 10 + c - '0';
        c = getchar();
    } while ('0' <= c && c <= '9');
    return ret * f;
}
const LL MOD = 1e9 + 7;
int n, m;
LL dp[220][220][220];
char str[220];
int main()
{
    int delta;
    int kase;
    kase = mread();
    while (kase--)
    {
        n = mread(), m = mread();
        scanf("%s", str + 1);
        for (int i = 0; i <= n; i++)
            for (int j = 0; j <= m; j++)
                for (int k = 0; k <= m; k++)
                    dp[i][j][k] = 0;
        dp[0][0][0] = 1;
        for (int j = 1; j <= m; j++)
        {
            for (int k = 0; k <= j; k++)
            {
                dp[0][j][k] = (dp[0][j][k] + dp[0][j - 1][k + 1] + MOD) % MOD; //add a )
                if (k > 0)
                    dp[0][j][k] = (dp[0][j][k] + dp[0][j - 1][k - 1] + MOD) % MOD; // add a (
            }
        }
        for (int j = 1; j <= m; j++)
        {
            for (int i = 1; i <= n; i++)
            {
                if (str[i] == '(')
                    delta = 1;
                else
                    delta = -1;
                for (int k = 0; k <= m; k++)
                {
                    if (k - delta >= 0)
                        dp[i][j][k] = (dp[i][j][k] + dp[i - 1][j - 1][k - delta] + MOD) % MOD;
                    if (k + delta <= m)
                        dp[i][j][k] = (dp[i][j][k] + dp[i][j - 1][k + delta] + MOD) % MOD;
                }
            }
        }
        printf("%lld\n", dp[n][m][0]);
    }
    return 0;
}

J Link with Arithmetic Progression

思路：最小二乘拟合

#include <bits/stdc++.h>
using namespace std;
#define ld __float128
int x[100001];
 
void solve() {
    int n;
    cin >> n;
    ld sum = 0;
    for (int i = 1; i <= n; i++) {
        cin >> x[i];
        sum += x[i];
    }
    if (n & 1) {
        ld k = (n + 1) / 2;
        ld mid = sum / n;
        ld a = 0, b = 0, c = 0;
        for (int i = 1; i <= n; i++) {
            a += (i - k) * (i - k);
            b += -2 * (k - i) * (x[i] - mid);
            c += (x[i] - mid) * (x[i] - mid);
        }
        ld res = -1.0 * b * b / (4.0 * a) + c;
        printf("%.8Lf\n", (long double) res);
    }
    else {
        ld k = n / 2 + 0.5;
        ld mid = sum / n;
        ld a = 0, b = 0, c = 0;
        for (int i = 1; i <= n; i++) {
            a += (i - k) * (i - k);
            b += -2 * (k - i) * (x[i] - mid);
            c += (x[i] - mid) * (x[i] - mid);
        }
        ld res = -1.0 * b * b / (4.0 * a) + c;
        printf("%.8Lf\n", (long double) res);
    }
}
 
int main () {
     
    
    int t;
    cin >> t;
    while(t--) {
        solve();
    }
}

L Link with Level Editor I

思路：考虑 f(i, j)表示考虑到第 i个世界，目前在j的最短区间长度，转移分为走给出的边和直接不动两种转移即可，由于空间的限制需要压掉第一维。

#include<bits/stdc++.h>
using namespace std;
vector<int> g[10005];
int main(){
    int n, m, dp[2][10005], ans = 0x3f3f3f3f;
    cin >> n >> m;
    dp[1][1] = 1;
    for(int i = 1;i <= n; i ++ ){
        int l;
        cin >> l;
        for(int j = 1;j <= m;j ++) {
            g[j].clear();
            dp[(i+1)%2][j] = 0;
        }
         
        dp[(i+1)%2][1] = i + 1;
        for(int j = 1;j <= l;j ++){
            int u, v;
            cin >> u >> v;
            g[u].push_back(v);
        }
         
        for(int j = 1;j <= m;j ++){
            for(auto k : g[j]){
                dp[(i+1)%2][k] = max(dp[(i+1)%2][k], dp[i%2][j]);
                if(k == m && dp[(i+1)%2][k] != 0) ans = min(ans, i - dp[(i+1)%2][k] + 1);
            }
        }
         
         for(int j = 1;j <= m;j ++) 
             dp[(i+1)%2][j] = max(dp[(i+1)%2][j], dp[i%2][j]);
         
        if(dp[i%2][m] != 0) ans = min(ans, i - dp[i%2][m] + 1);
    }
     
    //if(dp[(n+1)%2][m] != 0) ans = min(ans, n - dp[(n+1)%2][m] + 1);
     
    if(ans == 0x3f3f3f3f) cout << "-1";
    else cout << ans;
}