ABC369 C-G题解 (AtCoder Beginner Contest 369)

 

C

对于一个等差数列，它里面包含的等差数列（取这个数列的第i位~第j位），必定也是等差数列。

寻找等差数列的时候，如果一个等差数列，向最左/最右加1个数后，仍是等差数列，则把它们加上。从而寻找所有场上的等差数列，必定是不重叠的，等差数列彼此独立。

从而可以从1遍历到n，O(n)复杂度。

对于每一段等差数列，只统计里面包含的长度大于等于2的等差数列。最后再加上长度等于1的等差数列，即为单独的每个数，为n。这样，思路会清晰一点

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=2e5+10;

LL a[maxn];

int main()
{
    LL n,i,j,d;
    LL sum=0;
    cin>>n;
    for (i=1;i<=n;i++)
        cin>>a[i];
    j=1;
    for (i=1;i<n;)
    {
        d=a[i+1]-a[i];
        j=i;
        i++;
        while (i<n && a[i+1]-a[i]==d)
            i++;
        sum+=1LL*(i-j)*(i-j+1)/2;
    }
    cout<<sum+n;

    return 0;
}

 

 

D

DP

写成数组形式，好理解一点，写少一点代码

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=2e5+10;

LL f[maxn][2];


int main()
{
    LL n,i,a;
    f[0][0] = 0;
    f[0][1] = -1e18;
    cin>>n;
    for (i=1;i<=n;i++)
    {
        cin>>a;
        f[i][0] = max(f[i-1][0], f[i-1][1] + a*2);
        f[i][1] = max(f[i-1][1], f[i-1][0] + a);
    }
    
    cout<<max(f[n][0],f[n][1]);
    return 0;
}

 

E

floyd 求两两每个点之间的距离 + dfs获得几个桥所有可能的顺序

看到别人有用next_permutation，而且是挺多人用这个，挺不错。

但是后面，直接一行写出情况，对于大部分人来说是不是容易写错？而且关键是挺多人都这样写，我感觉比较神奇emmm。我个人，感觉用dfs相对不容易写错。

dfs获得几个桥所有可能的顺序，其实就很像旅行商问题，所有城市都访问一遍。然后这里是桥可以选择两个方向，也不好用状态压缩。

g个点，2^g个方向，桥的顺序，g!排列组合，每种桥方向类型，g个权值和相加，O(2^g*g!*g) 19,200 再乘个Q，没问题

 

 

我在比赛的时候，把floyd的顺序搞反了，然后几天找不到问题，真的绷不住了！！！floyd算法，三重循环的顺序问题，不要写错了 - congmingyige - 博客园 (cnblogs.com)

 

 

/*
n,m的大小，对应创建数组的大小，不要弄混，特别是这类题，n<=400，m<=2e5，提交前要检查一遍。当RE的时候，就要第一时间意识到数组大小设置错误的问题

怎么也调不出问题，包括检查代码，造样例，看题面，就立刻先切换到下一题。没必要花那么多时间耗在上面，否则检查错误，采用错误的方法，做很多无用功。而且影响做题时间和效率。这些时间，今早做下一题，有可能就做出来其它题了
做选择，要么全攻下一题（意识到难发现错误在哪，立刻切换，检查时间不要太长），要么剩下这些时间，全力检查这一题，不要既这又那
用assert等方式找一下问题所在，还有造一下大样例
*/
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=4e2+10;
const int maxm=2e5+10;

LL u[maxm],v[maxm],t[maxm],dist[maxn][maxn],b[10],g,n,result;
bool vis[10];

void dfs(LL d, LL ans, LL road)
{
    LL i,j;
    if (ans==g)
    {
        result = min(result, road+dist[d][n]);
        return;
    }
    for (i=1;i<=g;i++)
        if (vis[i]==0)
        {
            j=b[i];

            vis[i]=1;
            dfs(v[j], ans+1, road+dist[d][u[j]] + t[j]);
            vis[i]=0;

            vis[i]=1;
            dfs(u[j], ans+1, road+dist[d][v[j]] + t[j]);
            vis[i]=0;
        }
}

int main()
{
    LL m,q,i,j,k;
    cin>>n>>m;
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++)
            dist[i][j] = 1e15;
    for (i=1;i<=n;i++)
        dist[i][i]=0;
    for (i=1;i<=m;i++)
    {
        cin>>u[i]>>v[i]>>t[i];
        dist[ u[i] ][ v[i] ] = dist[ v[i] ][ u[i] ] = min(dist[ u[i] ][ v[i] ], t[i]);
    }
    
    for (k=1;k<=n;k++)
        for (i=1;i<=n;i++)
            for (j=1;j<=n;j++)
                 dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j]);
    /*
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++)
            assert(dist[i][j]<1e15);
    */

    cin>>q;
    while (q--)
    {
        cin>>g;
        for (i=1;i<=g;i++)
            cin>>b[i];
        memset(vis,0,sizeof(vis));
        result=1e18;
        dfs(1,0,0);
        //assert(result<1e18);
        cout<<result<<endl;
    }

    return 0;
}
/*
g个点
2^g个方向，桥的顺序，g!排列组合，每种桥方向类型，g个权值和相加，O(2^g*g!*g) 19,200 再乘个Q，没问题
*/

 

F

应该看一下题面，在剩余1个小时的时候，这样才有时间做和取舍（题D、E)

这种属于题面很容易理解，也很容易想到解法的。就是写的过程中容易写错，debug也是，需要时间长一点

感觉这是高手和某类菜鸟的区别。某类菜鸟也可以很快找到解法，就是写代码和调试代码的时候，对于这类比较琐碎的代码，需要写挺久

 

能想到的基础题目是用DP做，二维方格，dp[i][j]=max(dp[i-1][j], dp[i][j-1])。

现在是n、m相乘比较大，然后硬币数比较少。

因为只能向下或者向右，所以对于一个点，只有列的数值小于等于它的点，才能访问到它。这容易想到树状数组。同样，对于行，也是只有行的数值小于等于它的点，才能访问到它。

f[i]= max(f[j]) + 1。 i表示这个点的列数值为i，j是所有小于i的数，用树状数组获取f数组里1~i的最大值。

按照硬币行数值优先，然后列数值优先的顺序排序，然后依次访问硬币。可以确保，对于该硬币，前面的硬币的行都是小于等于它，后面的硬币的行都是大于它，或者行等于它但是列大于它，无法从后面的硬币到该硬币。

 

/*
应该看一下题面，在剩余1个小时的时候，这样才有时间做和取舍（题D、E)
这种属于题面很容易理解，也很容易想到解法的。就是写的过程中容易写错，debug也是，需要时间长一点
感觉这是高手和某类菜鸟的区别。某类菜鸟也可以很快找到解法，就是写代码和调试代码的时候，对于这类比较琐碎的代码，需要写挺久

用xpre,ypre,x,y，这样变量不容易搞错。还有，找问题的，多检查一下变量，这种变量最容易写错
*/
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=2e5+10;

pair<int,int> par[maxn];

map<pair<int,int>, pair<int,int> > mp;

pair<int, int> pre[maxn];
int f[maxn];
vector<string> vec;

void add_path(pair<int,int> dpre, pair<int,int> d)
{
    int i,j;
    string str="";
    for (i=dpre.first;i<d.first;i++)
        str+='D';
    for (j=dpre.second;j<d.second;j++)
        str+='R';
    vec.push_back(str);
}

void dfs(pair<int,int> d)
{
    pair<int,int> dpre;

    dpre = mp[d];

    if (dpre!=make_pair(-1,-1))
    {
        add_path(dpre,d);
        dfs(dpre);
    }
    else
        add_path(make_pair(1,1),d);
}

int main()
{
    int h,w,n,x,y,v,i,j,y_max=2e5;
    pair<int,int> dpre,d;
    cin>>h>>w>>n;
    memset(f,0,sizeof(f));
    for (i=0;i<n;i++)
    {
        cin>>x>>y;
        par[i] = make_pair(x,y);
    }
    sort(par, par+n);

    for (j=0;j<n;j++)
    {
        x = par[j].first;
        y = par[j].second;
        dpre = make_pair(-1,-1);

        v = 0;
        for (i=y;i>=1;i-=i&-i)
            if (f[i]>v)
            {
                v=f[i];
                dpre = pre[i];
            }

        v++;

        if (v>f[y])
        {
            d = make_pair(x,y);
            mp[d] = dpre;

            for (i=y;i<=y_max;i+=i&-i)
                if (v>f[i])
                {
                    f[i]=v;
                    pre[i]=d;
                }
        }
    }
    
    v=0;
    for (i=y_max;i>=1;i-=i&-i)
        if (f[i]>v)
        {
            v=f[i];
            dpre=pre[i];
        }
    cout<<v<<endl;
    add_path(dpre,make_pair(h,w));
    dfs(dpre);
    reverse(vec.begin(), vec.end());
    for (auto d:vec)
        cout<<d;

    return 0;
}

 

学习官方代码，

 

vector 初始化，第二个数，就是vector里初始化的数值

 

LIS，二分的写法，4行就搞定了？？！！！

对于pre数组，记录点id，而不是记录二维坐标，这样方便一点，写少一点代码

用二分的写法，而不是树状数组的写法，只用修改一次pre，这个点的pre就是数组里上一个点，用树状数组，每次+lowbit后，都要判断修改一次，总感觉代码量相对比较大，不利索

pre[i] = (it ? id[it - 1] : -1); 这个写法不错

 

官方也是用while、vector记录从终点出发，不断pre的点序列，然后用reverse，的确，这个好用。我感觉用dfs，写得挺不舒服的

    int now = id[m];
    while (now != -1) {
        path.push_back(coins[now]);
        now = pre[now];
    }
    path.emplace_back(1, 1);
    reverse(path.begin(), path.end());

 

 

#include <bits/stdc++.h>

using namespace std;

int main() {
    int h, w, n;
    cin >> h >> w >> n;
    vector<pair<int, int>> coins;
    for (int i = 0; i < n; i++) {
        int r, c;
        cin >> r >> c;
        coins.emplace_back(r, c);
    }
    sort(coins.begin(), coins.end());
    vector<int> dp(n, 1e9), id(n, -1), pre(n);
    for (int i = 0; i < n; i++) {
        int it = upper_bound(dp.begin(), dp.end(), coins[i].second) - dp.begin();
        dp[it] = coins[i].second;
        id[it] = i;
        pre[i] = (it ? id[it - 1] : -1);
    }
    int m = n - 1;
    while (id[m] == -1) --m;
    vector<pair<int, int>> path = {{h, w}};
    int now = id[m];
    while (now != -1) {
        path.push_back(coins[now]);
        now = pre[now];
    }
    path.emplace_back(1, 1);
    reverse(path.begin(), path.end());
    string s;
    for (int i = 0; i < (int) path.size() - 1; i++) {
        int d = path[i + 1].first - path[i].first;
        int r = path[i + 1].second - path[i].second;
        while (d--) s.push_back('D');
        while (r--) s.push_back('R');
    }
    cout << m + 1 << '\n' << s << '\n';
}

 

G

我们只需要选择叶子节点。如果选择了其它点，那么它的孙子节点必定比它更适合。

记录点1到某个点的长度，从大到小排序依次取。

取了一个点后，点1到这个点经过的边，所有的边值都要修改为0，即点1到其它点经过的边中，再用到这些边，也无法增加权值。

暴力做的话，即每个取一个点后，修改受影响的其它点（有与这个点共用边的），不行。比如这个图 ，每次拿最左边的点，然后靠右的点都要受到重新计算权值，要修改的点的数目太多了。

 

树的长链剖分

树链剖分 - OI Wiki (oi-wiki.org)

 

 

区别在于，定义 重子节点 表示其子节点中子树经过边权值之和最大的子结点

无论选择的顺序如何（权值大小的排序），我们必定是按照长链剖分的方式选择叶子节点/边。

 

我用的方法是，对于一个点的所有子节点，不计算重点（只会有一个或者没有），剩余其它点，都统计长度（从这个点开始到某个叶节点的路径），同时，不要遗漏根节点。就比如上图里，记录所有白色点为起始的路径。

Atcoder Beginner Contest 369 - maniubi - 博客园 (cnblogs.com) 这个的代码，统计轻子节点，放在了dfs函数之外。

 

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL unsigned long long

const LL mod_1=1e9+7;
const LL mod_2=998244353;

const double eps_1=1e-5;
const double eps_2=1e-10;

const int maxn=2e5+10;

vector<pair<LL, LL> > adj[maxn];
bool vis[maxn];
LL len[maxn],fa[maxn],ans[maxn];
vector<LL> result;

void dfs(LL d)
{
    LL child,value,cur_len,hson;
    vis[d]=1;
    for (auto single:adj[d])
    {
        child = single.first;
        value = single.second;

        if (!vis[child])
        {
            dfs(child);

            cur_len = len[child] + value;

            if (cur_len>len[d])
            {
                len[d] = cur_len;
                hson = child;
            }
        }
        else
            fa[d] = child;
    }

    for (auto single:adj[d])
    {
        child = single.first;
        value = single.second;
        if (child!=hson && child!=fa[d])
            result.push_back(len[child]+value);
    }
}

int main()
{
    LL n,i,u,v,w;
    cin>>n;
    for (i=1;i<n;i++)
    {
        cin>>u>>v>>w;
        adj[u].push_back(make_pair(v,w));
        adj[v].push_back(make_pair(u,w));
    }

    memset(vis,0,sizeof(vis));
    memset(len,0,sizeof(len));
    fa[1]=0;
    dfs(1);

    result.push_back(len[1]);
    sort(result.begin(),result.end(),greater<LL>());
    
    i=0;
    ans[0]=0;
    for (auto d:result)
    {
        i++;
        ans[i]=ans[i-1]+d;
    }
    i++;
    while (i<=n)
    {
        ans[i]=ans[i-1];
        i++;
    }
    for (i=1;i<=n;i++)
        cout<<ans[i]*2<<endl;


    return 0;
}

 

学习它这种写法：

    int ans = 0;
    for (int i = 0; i < n; i ++) {
        if (i < d.size()) ans += d[i];
        cout << ans * 2ll << "\n";
    }