Codeforces 1000 组合数可行线段倒dp 边双联通缩点求树直径

最新推荐文章于 2020-08-18 21:31:31 发布
最新推荐文章于 2020-08-18 21:31:31 发布
阅读量86 收藏
点赞数
原文链接：http://www.cnblogs.com/Aragaki/p/9238272.html
版权

A

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7, gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int MAXN = 2e5 + 5, MAXM = 2e5 + 5, N = 2e5 + 5;
const int MAXQ = 100010;
/*int to[MAXM << 1], nxt[MAXM << 1], Head[MAXN], tot = 1;
inline void addedge(int u, int v)
{
        to[++tot] = v;
        nxt[tot] = Head[u];
        Head[u] = tot;
}*/
inline void read(int &v)
{
        v = 0;
        char c = 0;
        int p = 1;
        while (c < '0' || c > '9')
        {
                if (c == '-')
                {
                        p = -1;
                }
                c = getchar();
        }
        while (c >= '0' && c <= '9')
        {
                v = (v << 3) + (v << 1) + c - '0';
                c = getchar();
        }
        v *= p;
}
int num[15];
int anser[15];
map<string, int> mp;
int main()
{
        mp["S"] = 1, mp["M"] = 2, mp["L"] = 3;
        mp["XL"] = 4, mp["XXL"] = 5, mp["XXXL"] = 6;
        mp["XS"] = 7, mp["XXS"] = 8, mp["XXXS"] = 9;
        int n;
        int ans = 0;
        read(n);
        string now;
        for (int i = 1; i <= n; i++)
        {
                cin >> now;
                num[mp[now]]++;
        }
        for (int i = 1; i <= n; i++)
        {
                cin >> now;
                anser[mp[now]]++;
        }
        for (int i = 1; i <= 14; i++)
        {
                ans += abs(num[i] - anser[i]);
        }
        cout << ans / 2 << endl;
        return 0;
}
View Code

B

分奇偶即可

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7, gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int MAXN = 2e5 + 5, MAXM = 2e5 + 5, N = 2e5 + 5;
const int MAXQ = 100010;
/*int to[MAXM << 1], nxt[MAXM << 1], Head[MAXN], tot = 1;
inline void addedge(int u, int v)
{
        to[++tot] = v;
        nxt[tot] = Head[u];
        Head[u] = tot;
}*/
inline void read(int &v)
{
        v = 0;
        char c = 0;
        int p = 1;
        while (c < '0' || c > '9')
        {
                if (c == '-')
                {
                        p = -1;
                }
                c = getchar();
        }
        while (c >= '0' && c <= '9')
        {
                v = (v << 3) + (v << 1) + c - '0';
                c = getchar();
        }
        v *= p;
}
int num[200005];
int anser = 0;
int number[200005];
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);

        int n, m;
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
        {
                cin >> num[i];
        }
        n++;
        num[n] = m;
        for (int i = 1; i <= n; i++)
        {
                number[i] = number[i - 1];
                if (i & 1)
                {
                        int add = num[i] - num[i - 1];
                        number[i] += add;
                }
        }
        anser = number[n];
        for (int i = 1; i <= n - 1; i++)
        {
                if (num[i] - 1 > num[i - 1] || num[i] + 1 < num[i + 1])
                {
                        if (i & 1)
                        {
                                int now = number[i] + m - num[i] + number[i] - number[n] - 1;
                                anser = max(anser, now);
                        }
                }
        }
        cout << anser << endl;
        return 0;
}
View Code

C

离散化前缀和

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7, gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int MAXN = 2e5 + 5, MAXM = 2e5 + 5, N = 2e5 + 5;
const int MAXQ = 100010;
/*int to[MAXM << 1], nxt[MAXM << 1], Head[MAXN], tot = 1;
inline void addedge(int u, int v)
{
        to[++tot] = v;
        nxt[tot] = Head[u];
        Head[u] = tot;
}*/
inline void read(int &v)
{
        v = 0;
        char c = 0;
        int p = 1;
        while (c < '0' || c > '9')
        {
                if (c == '-')
                {
                        p = -1;
                }
                c = getchar();
        }
        while (c >= '0' && c <= '9')
        {
                v = (v << 3) + (v << 1) + c - '0';
                c = getchar();
        }
        v *= p;
}
ll number[600005];
ll ans[600005];
ll l[200005], r[200005];
ll anser[200005];
map<ll, ll> mp;
map<ll, ll> mpb;
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);

        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
                cin >> l[i] >> r[i];
                number[3 * i - 2] = l[i];
                number[3 * i - 1] = r[i];
                number[3 * i] = r[i] + 1;
        }
        sort(number + 1, number + 3 * n + 1);
        int pop = unique(number + 1, number + 3 * n + 1) - number - 1;
        //        for (int i = 1; i <= pop; i++)
        //        {
        //                cout << number[i] << " ";
        //        }
        //        cout << endl;
        for (int i = 1; i <= pop; i++)
        {
                mp[number[i]] = i;
                mpb[i] = number[i];
        }
        for (int i = 1; i <= n; i++)
        {
                ans[mp[l[i]]]++;
                ans[mp[r[i]] + 1]--;
        }
        for (int i = 1; i <= pop; i++)
        {
                ans[i] += ans[i - 1];
        }
        ll cur = ans[1];
        for (int i = 1; i <= pop - 1; i++)
        {
                cur = ans[i];
                anser[cur] += mpb[i + 1] - mpb[i];
        }
        cur = ans[pop];
        anser[cur]++;
        for (int i = 1; i <= n; i++)
        {
                cout << anser[i] << " ";
        }
        cout << endl;
        return 0;
}
View Code

D

倒着DP

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 998244353, gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int MAXN = 2e5 + 5, MAXM = 2e5 + 5, N = 2e5 + 5;
const int MAXQ = 100010;
/*int to[MAXM << 1], nxt[MAXM << 1], Head[MAXN], tot = 1;
inline void addedge(int u, int v)
{
        to[++tot] = v;
        nxt[tot] = Head[u];
        Head[u] = tot;
}*/
inline void read(int &v)
{
        v = 0;
        char c = 0;
        int p = 1;
        while (c < '0' || c > '9')
        {
                if (c == '-')
                {
                        p = -1;
                }
                c = getchar();
        }
        while (c >= '0' && c <= '9')
        {
                v = (v << 3) + (v << 1) + c - '0';
                c = getchar();
        }
        v *= p;
}
ll zuhe[1005][1005];
int n;
ll num[1005];
ll ans[1005];
ll anser = 0;
void init()
{
        zuhe[0][0] = 1;
        for (int i = 1; i <= n; i++)
        {
                zuhe[i][0] = 1;
                for (int j = 1; j <= i; j++)
                {
                        zuhe[i][j] = (zuhe[i - 1][j] + zuhe[i - 1][j - 1]) % mod;
                }
        }
}
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);

        cin >> n;
        ans[n + 1] = 1;
        init();
        for (int i = 1; i <= n; i++)
        {
                cin >> num[i];
        }
        for (int i = n; i >= 1; i--)
        {
                if (num[i] <= 0)
                {
                        continue;
                }
                for (int j = i + num[i] + 1; j <= n + 1; j++)
                {
                        ans[i] += zuhe[j - i - 1][num[i]] * ans[j];
                        ans[i] %= mod;
                }
        }
        for (int i = 1; i <= n; i++)
        {
                anser += 1LL * ans[i];
                anser %= mod;
        }
        cout << anser << endl;
        return 0;
}
View Code

E

边双联通分量缩点后是一颗树 再求树的直径即可

/*Huyyt*/
#include <bits/stdc++.h>
#include <vector>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cstdlib>
#include <stack>
#include <vector>
#include <set>
#include <map>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N = 300000 + 5;
const int M = 600000 + 5;
struct EDGE
{
    int v, next;
} edge[M * 2];
int first[N], low[N], dfn[N], belong[N], degree[N], sta[M], instack[M];
vector<int> gra[300005];
int g, cnt, top, scc;
int min(int a, int b)
{
    return a < b ? a : b;
}
void AddEdge(int u, int v)
{
    edge[g].v = v;
    edge[g].next = first[u];
    first[u] = g++;
}
void Tarjan(int u, int fa)
{
    int i, v;
    low[u] = dfn[u] = ++cnt;
    sta[++top] = u;
    instack[u] = 1;
    for (i = first[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].v;
        if (i == (fa ^ 1))
        {
            continue;
        }
        if (!dfn[v])
        {
            Tarjan(v, i);
            low[u] = min(low[u], low[v]);
        }
        else if (instack[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if (dfn[u] == low[u])
    {
        scc++;
        while (1)
        {
            v = sta[top--];
            instack[v] = 0;
            belong[v] = scc;
            if (v == u)
            {
                break;
            }
        }
    }
}
map<pair<int, int>, int> mp;
int ssssstart, eeeeeeend;
int distence[300005];
int visit[300005];
void getdis(int x)
{
    visit[x] = 1;
    int len = gra[x].size();
    for (int i = 0; i < len; i++)
    {
        int to = gra[x][i];
        if (visit[to])
        {
            continue;
        }
        distence[to] = distence[x] + 1;
        getdis(to);
    }
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    memset(first, -1, sizeof(first));
    int n, m;
    int u, v;
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        cin >> u >> v;
        AddEdge(u, v);
        AddEdge(v, u);
    }
    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
        {
            Tarjan(i, -1);
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = first[i]; j != -1; j = edge[j].next)
        {
            v = edge[j].v;
            if (belong[i] != belong[v])
            {
                if (!mp[make_pair(belong[i], belong[v])])
                {
                    gra[belong[i]].push_back(belong[v]);
                    gra[belong[v]].push_back(belong[i]);
                    mp[make_pair(belong[i], belong[v])] = mp[make_pair(belong[v], belong[i])] = 1;
                }
            }
        }
    }
    getdis(1);
    int maxnn = -1;
    for (int i = 1; i <= scc; i++)
    {
        if (distence[i] > maxnn)
        {
            ssssstart = i;
            maxnn = distence[i];
        }
    }
    mem(visit, 0), mem(distence, 0);
    getdis(ssssstart);
    maxnn = -1;
    for (int i = 1; i <= scc; i++)
    {
        if (distence[i] > maxnn)
        {
            eeeeeeend = i;
            maxnn = distence[i];
        }
    }
    cout << distence[eeeeeeend] << endl;
    return 0;
}
View Code

 

转载于:https://www.cnblogs.com/Aragaki/p/9238272.html

baichuan9723
关注
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
贪心正确性显然：R大的至少可以选则R做为点来用。所以按R升序遍历，每次优先选左边的，能让后边的可选的更多。 用set维护可选的数即可。 这题加了个输出2个方案。 我们考虑最简单的情况：即确定一个序列后，是否有2...
CodeForces – 1312E Array Shrinking(区间dp)
01-03
题目分析：最优性问题，且是对区间操作的，而且数据范围满足 n^3 的时间复杂度，综上可以考虑区间dp，因为题目已经明确了需要求什么，所以我们不妨设 dp[ i ][ j ] 为区间 [ i , j ] 合并后的最短数列的长度，因为...
CodeForces 852B Neural Network country（dp+矩阵快速优化）
alpc_qleonardo
10-01 598
好久没有遇到这么单纯的矩阵快速幂的题目。         大致题意就是，给你一个网络，这个网络分层，除了源汇直接相连的点以外，其余所有的层都是相同的。然后问你，从源点出发到汇点，路径权值和为某个特定的数字M的倍数的方案有多少种。         事实证明，题目的数据范围确实是一个突破口。本题给出M的范围是100，可以说就是突破口。经过长期的做题，很容易知道这里直接用当前花费在M下的剩余系来表示状态即可，然后可以有前一层的状态转移到后一层。在不考虑层数和每一层点数的限制下，我们可以有如下状态转移方程dp[i]
codeforces 852B - Neural Network country
09-04 158
http://codeforces.com/contest/852/problem/B 题意：有一幅有向图，除了源点和汇点有 L 层，每层 n 个点。 第 i+1 层的每个点到 第 i+2 层的每个点都有一条边，边的权值为有向边终点的权值。求源点到汇点的路径长度能被 m 整除的个数。 题解：快速幂。a[i] 表示从第 1 层到第 a 层总路径长度为 i （i % m） 的数目，b[j...
codeforces 777E dp+线段树+离散化
WeiGuan_的博客
03-02 887
codeforces 777E
Codeforces 1043F Make It One 经典调和级数算法,组合数,dp
热门推荐
Fuko_Ibuki的博客
08-18 1万+
题意 给你n个数,取出一些数使这些数的最大公约数为1,求取出数字的最少个数,不能输出−1.给你n个数,取出一些数使这些数的最大公约数为1,求取出数字的最少个数,不能输出-1.给你n个数,取出一些数使这些数的最大公约数为1,求取出数字的最少个数,不能输出−1. 数据范围两个3×1053\times 10^53×105. 秒杀 可以看到当几个质数分别为a,b,c,d,e,f......a,b,c,d,e,f......a,b,c,d,e,f......时,abcde,abcdf,abcef,abdef,acde
【线段树模板以及Codeforces线段树专题总结】
lajiyuan的博客
04-09 3669
线段树模板 //线段树一般用来解决可合并的区间问题 //树上维护子树区间的问题也可以通过dfs序+线段树去维护 //不要忘记build，dfs序问题build时注意下标 //数组记得开4倍，push_down一定要想好顺序 //对于每个问题，我们只要考虑清楚push_down和push_up的写法即可 //当问题不好处理的时候，想象一下对于单次询问暴力的做法，再进行区间操作 struct T { ...
Codeforces Round #271 (Div. 2) E. Pillars（线段树优化DP）
AC_Arthur的专栏
01-25 1310
题目链接：点击打开链接 题意：一个n个数的序列，每个数有一个高度值h[i]。 求一个最长子序列，要求相邻两个数满足| h[i] - h[i-1] | >= d。 并要求打印出该序列。 类似于最长上升子序列， DP思想很简单， 但是可惜n太大了， 二重循环会超时。 所以要想办法优化掉第二层循环。 观察发现， 第二层所做的事情就是在所有满足j= d 的j中找到最大的d[j]。 j 把不等式
Codeforces 316E3 Summer Homework 线段树+前缀和
The_OIer的博客
07-18 2858
题目链接：传送门 题外话：这是一个蒟蒻在看不懂所有题解时，受到巨神mhy的帮助后写的题解。 我太蒻了qwq 题目描述 By the age of three Smart Beaver mastered all arithmetic operations and I love zwt got this summer homework from the amazed teacher: You are ...
codeforces 573B B. Bear and Blocks(线段树+dp)
llin-黎辰
09-09 1749
题目链接：codeforces 573B题目大意：给出n个连续塔，每个塔有高度hih_i,每次取走最外层的块，问需要多少次操作能够拿光所有的块。题目分析： 首先我们可以知道第一次操作时，对于每个塔的变化满足如下的公式：hi=min(hi−1,hi−1,hi+1)h_i =min ( h_{i-1} , h_i -1 , h_{i+1}) 每次操作都满足如下的递推式，我们递推一下得到第k次操作第i的塔
codeforces 340D D. Bubble Sort Graph(dp+线段树)
llin-黎辰
09-15 1149
题目链接：codeforces 340D题目大意：给出一个程序，就是冒泡排序，每次如果发现相邻两个数前一个大于后一个，交换位置后建边，问最后得到的这个图中的最大独立集，这个最大独立集定义为所有的点都不相邻的最大点的集合的规模。题目分析： 首先我们可以知道对于a[i],它只会且一定会与后面的比它小的建边，所以我们只需要固定第一个点，然后找最长上升子序列即可。（这样能够保证没有相邻的点） 定义状态dp[
Wi-Fi【Codeforces Round #587 (Div. 3)】【线段树优化dp】
既然弱小，就只顾变强就是了
09-21 1137
题目链接【Codeforces 1216F】 You work as a system administrator in a dormitory, which has????nrooms one after another along a straight hallway. Rooms are numbered from11to????n. You have to connect all????n...
Codeforces 1083 A. The Fair Nut and the Best Path（树形DP）
01-03
给一棵树，每个点有一个点权，每条边有一个边权，求一条链使得点权和-边权和最大。 思路： 由于我没看清楚题意，以为是求联通子图的点权和-边权和最大，用link-cut-tree写换根，wa10了两发。 回头重新看了一下题意，...
【java毕业设计】校内跑腿业务系统源码（springboot+vue+mysql+说明文档）.zip
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
【java毕业设计】大学志愿填报系统源码（springboot+vue+mysql+说明文档）.zip
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
基于java的网吧管理系统答辩PPT.pptx
11-04
基于java的网吧管理系统答辩PPT.pptx
基于java的基于SSM架构的网上书城系统答辩PPT.pptx
11-04
基于java的基于SSM架构的网上书城系统答辩PPT.pptx
tornado-6.1-cp37-cp37m-win32.whl
11-04
tornado-6.1-cp37-cp37m-win32.whl
气泡排序、插入排序、选择排序、快速排序、希尔排序、堆排序、合并排序-SortAlgorithm.zip
最新发布
11-04
c语言气泡排序、插入排序、选择排序、快速排序、希尔排序、堆排序、合并排序_SortAlgorithm.zip
CodeForces - 982C 树形DP
07-25
引用\[1\]中提到了一种树形动态规划的方法来解决CodeForces - 982C问题。在这个问题中，subtree指的是子连通块，而不是子树。为了使cnt_white - cnt_black尽可能大，可以使用两次树形动态规划来求解。第一次是自底...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值