atcoder绿题选做

ABC305:E   https://atcoder.jp/contests/abc305/tasks/abc305_e

题意：给定一个无向图，给定k个守卫，每个守卫有h[i]的耐力值，如果是一个在图中是被保护的要满足和守卫的距离至少为h[i],让你升序打印所有被守卫的点

解题思路：可以从守卫出发，看守卫在可以走的情况下最远走到哪，最后统计被更新的点，核心做法是多源bfs和最短路的思想

#include<cstdio>//将每个点的守卫向外扩散，每次扩散消耗体力为1，如果体力为0则停止
#include<cstring>//最后统计被更新的点就可以，核心思想是多源bfs
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 4e5+10;
int n,m,e[N],h[N],ne[N],idx,k;
bool vis[N];
int dis[N];
priority_queue<PII>q;//这里需要用大根堆，因为每次取堆头的都是剩余体力最大的
void add(int a,int b)
{
    e[++idx]=b,ne[idx]=h[a],h[a]=idx;
}
void bfs()
{
    memset(dis,-1,sizeof dis);
    for(int i=1;i<=k;i++)
    {
        int a,b;
        cin>>a>>b;
        dis[a]=b;
        q.push({b,a});
    }
    while(!q.empty())
    {
        auto tmp=q.top();
        q.pop();
        int d=tmp.first;
        int x=tmp.second;
        if(dis[x]>d)    continue;
        if(d)
        //if(d<=0)    continue;
        {
            for(int i=h[x];~i;i=ne[i])
            {
                int y=e[i];
                if(dis[y]<d-1)
                {
                    dis[y]=d-1;
                    q.push({d-1,y});
                }
            }
        }
    }
}
signed main()
{
    IOS;
    memset(h,-1,sizeof h);
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u,v);
        add(v,u);
    }
    bfs();
    vector<int>ans;
    for(int i=1;i<=n;i++)
    {
        if(dis[i]>=0)    ans.push_back(i);
    }
    cout<<ans.size()<<endl;
    for(auto &it:ans)
    {
        cout<<it<<" ";
    }
    return 0;
}

 

ABC305:D  https://atcoder.jp/contests/abc305/tasks/abc305_d

题意：高桥喜欢睡觉写日志，日志的长度为奇数且第奇数个元素代表他起床时刻，第偶数个元素代表他上床睡觉的时刻，现给定区间[l,r]，询问在此区间内高桥的睡眠时间长为多少

 

解题思路：其实第一印象猜大概什么做法的话肯定是二分，因为要选择睡眠时间肯定是要找在a[i]内大于等于两个区间界限的时间点，，然后可能涉及到计算一段区间长度的问题，这里可以用前缀和来处理，然后就根据题意进行区间运算了

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 2e5+10;
int n,a[N];
int q,l,r;
int s[N];
vector<int>gb;
vector<int>gu;
signed main()
{
    IOS;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        s[i]=s[i-1]+(a[i]-a[i-1])*(i&1);
        //cout<<s[i]<<" ";
    }
    cin>>q;
    //cout<<endl;
    while(q--)
    {
        int sum=0;
        cin>>l>>r;
        int id1=lower_bound(a+1,a+1+n,l)-a;
        int id2=lower_bound(a+1,a+1+n,r)-a;
        // if(id1>=n)
        // {
            // cout<<0<<endl;
            // continue;
        // }
        // if(a[id1]%2==0&&a[id1-1]%2==0)
        // {
            // sum+=a[id1]-a[id1-1];    
        // }
        // for(int i=a[id1];i<=n&&a[i]<=r;i++)
        // {
            // if()
        // }
        sum=s[id2]-s[id1-1];//首先加上 a[posl]→a[posr]的睡眠分钟数
        if(id1&1)//判断时间段l->a[posl]是否为睡眠时间
        {
            sum-=l-a[id1-1];
        }
        if(id2&1)//判断是否是睡眠时间
        {
            sum-=a[id2]-r;
        }
        cout<<sum<<endl;
        
    }
    return 0;
}

 

ABC306D：https://atcoder.jp/contests/abc306/tasks/abc306_d

题意：给定n个菜，这些菜有一定的营养值且可能有毒1，可能无毒0，初始时候人的是健康的，如果他是在健康的状态下吃有毒的菜他会进入不健康状态，吃无毒的菜继续维持健康状态

如果他在不健康的状态下吃无毒的菜他会进入健康状态，反之他就挂了。

对于一些菜，这个人可以选择吃也可跳过，到最后如果i!=N再来一轮，i==N他会活着离开。

问此人在或者离开的情况下能获得最大的营养值是多少

tip:如果此人第一次吃到是有毒的菜那这一次菜的营养值不计入在内

 

解题思路：很典型的01背包，考虑在当前菜有毒/无毒情况下健康/不健康的进食获取值

#include<cstdio>//01背包问题
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define x first
#define y second
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 3e5+10;
int n;
PII a[N];
int nh=1;
bool vis[N];
int dp[N][2];
void init()
{
    for(int i=1;i<=N;i++)
    {
        dp[i][0]=-inf;
    }
}
signed main()
{
    IOS;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i].x>>a[i].y;
    }
    // sort(a+1,a+1+n,cmp);
    // stack<pair<bool,int>>q;
    // for(int i=1;i<=n;i++)
    // {
        // cout<<a[i].x<<" "<<a[i].y<<endl;
    // }
//     
    // if(a[1].x)
    // {
        // nh--;
    // }
    // else
    // {
        // nh=1;
    // }
    // int sum=0;
    // for(int i=2;i<=n;i++)
    // {
        // if(nh)
        // {
            // if(a[i].x)
            // {
                // nh--;
                // sum+=a[i].y;
            // }
            // else
            // {
                // nh=1;
                // sum+=a[i].y;
            // }
        // }
        // else
        // {
            // if(a[i].x)
            // {
                // continue;
            // }
            // else
            // {
                // sum+=a[i].y;
                // nh=1;
            // }
        // }
    // }
    // if(a[1].x)
    // {
        // q.push({1,a[1.y]});
    // }
    // else
    // {
        // q.push({0,a[1].y});
    // }
    // int sum=0;
    // for(int i=2;i<=n;i++)
    // {
        // auto tmp=q.top();
        // if(tmp.x)
        // {
            // if(!a[i].x)
            // {
                // sum+=a[i].y;
            // }
        // }
    // }
    // cout<<max(0ll,sum)<<endl;
    init();
    //dp[1][0]=-1;
    for(int i=1;i<=n;i++)
    {
        if(a[i].x)//当前有毒
        {
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]+a[i].y);//有毒的状态是从上一个有毒和上一个无毒且吃了当前
            dp[i][0]=dp[i-1][0];//当前无毒则可以跳过不吃，因为值有可能变小
        }
        else//当前无毒
        {
            dp[i][1]=dp[i-1][1];//值可能变小，不吃
            dp[i][0]=max({dp[i-1][0],dp[i-1][0]+a[i].y,dp[i-1][1]+a[i].y});//无毒的状态是从上一个无毒和上一个无毒且吃了当前还有上一个有毒
            //但吃了无毒解毒了
        }
    }
    cout<<max(dp[n][0],dp[n][1]);
    return 0;
}

 

ABC297E：https://atcoder.jp/contests/abc297/tasks/abc297_e

题意：给定n个价值为a[i]的商品，要求你至少买一种且你被允许购买多个同类的商品，找到你可能支付的第k最低价格，在这里如果有多套价格相同的商品，价格只被计算一次

 

解题思路：可以考虑每次用当前集合中的最低价对其他元素进行累加同时删掉此元素，这样进行k次操作后取集合中最小的元素其实就是答案

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 20;
const int M = 2e5+10;
int n,k;
int a[N];
signed main()
{
    IOS;
    cin>>n>>k;
    for(int i=1;i<=n;i++)    cin>>a[i];
    set<int>s;
    while(k--)
    {
        int tmp=*s.begin();
        s.erase(tmp);
        //cout<<*s.begin()<<endl;
        for(int j=1;j<=n;j++)
        {
            s.insert(a[j]+tmp);
        }
    }
    cout<<*s.begin();
    return 0;
}

 

ABC290D：https://atcoder.jp/contests/abc290/tasks/abc290_d

题意：给定下标从0开始的n个格子，对每一个格子你可以进行这样的操作：

1.将当前格子涂为0

2.令x=(A+D)%N,A是当前格子的下标

3.如果格子x被标记了，那就重复(x+1)%N

4.涂下标为x的格子

 

解题思路：当时只觉得是模拟，但发现其实没这么简单，正确做法是裴蜀定理，下面给出此题的证明过程

 

首先有结论:设g = gcd(A,B) A = ag，B = bg 。
a项式子 0B mod A,Bmod A, 2B mod A，......(a - 1)Bmod A。

特点是：

1.每项式子的值都是g的倍数。
2.且倍数为0～ a―1每一个数恰好出现一次。
证明:
1. B mod A = B — xA(x= B /A)= bg — xag = (b - xa)g。2.设有重复的倍数iBmod A =jBmod A(i!= j)。
iB-jB=(i-j)bg = yA为A的倍数(iB― jB) mod A=0模A余数相同，那么相减后再模A余数自然为0。(i一 j)bg = yag
因为a与b互质( a与b若还有大于1的公约数，那么gcd就不会是g 而是g * gcd(a,b))。所以(i一j)是a的倍数这显然与上式系数区间[0, a―1]相违背。

 

此题对于上述定理的应用

设g= gcd(N, D) N =ng，D = dg。
对于上述问题有跳跃的前n步为0 mod N, D mod N, 2D mod N，.... ， (n - 1)D mod N。每一项都是不重复的g 的倍数，所以不会触发条件2。而第n＋1步nD mod N = ndg = dN mod N =0。
开始有重复项第二轮开始，此时需要向前走一步(0，接下来又可以按(Dmod N)+ 1,(2D mod N)+ 1，....的顺序进行n轮跳跃。
每一轮n个直到所有格子都被遍历到。所以我们只需要确定我们在哪一轮，偏移量＋轮数即可轮数:len= (K- 1)/n。
偏移量:add= (K- 1) mod n。ans = add * D。
最初容易想到特殊情况，当D为N的因子时，前N/D步肯定没有重复，接下来每一步都是上一轮同样倍数＋1若为0,3,6,9 . .....下一轮即为1,4,7,10 . . ....
随后再引申到非因子的数应该也有一个循环节上进行考虑。

 

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
void solved()
{
    int N,D,k;
    cin>>N>>D>>k;
    int g=__gcd(N,D);
    int n=N/g;
    int d=D/g;
    int len=(k-1)/n;
    int pos=(k-1)%n;
    cout<<pos*D%N+len<<endl;
}
signed main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        solved();    
    }
    return 0;
}

 

ABC287E：https://atcoder.jp/contests/abc287/tasks/abc287_e

题意：给定n个字符串找出他们各自与其他字符串所具有的最大LCP值

LCP是指两个字符串的长度都大于等于i且在1~i直接具有相同的字符相匹配

 

解题思路：这不妥妥Trie？

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 5e5+10;
int n;
string s[N];
int trie[N][65];
int num[N],idx=1;
int ctoi(char c)
{
    int x;
    if(c>='A'&&c<='Z')    x=c-'A';//大写字母对应 0 ~ 25
    else if(c>='a'&&c<='z')    x=c-'a'+26;//小写字母对应 26 ~ 51，所以要减'a'，再加上26
    else x=c-'0'+52;//数字对应 52 ~ 61，同样的，减'0'再加上52
    return x;
}
void insert(string t)
{
    int p=0;
    for(int i=0;t[i];i++)
    {
        int u=t[i]-'a';
        if(!trie[p][u])    trie[p][u]=idx++;
        p=trie[p][u];
        num[p]++;
    }
}
int query(string t)
{
    int p=0;
    int ans=0;
    for(int i=0;t[i];i++)
    {
        int u=t[i]-'a';
        if(!trie[p][u])    return 0;
        p=trie[p][u];
        if(num[p]==1)    return ans;
        ans++;
    }
    return ans;
}
signed main()
{
    IOS;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>s[i];
        insert(s[i]);
    }
    for(int i=1;i<=n;i++)
    {
        cout<<query(s[i])<<endl;
    }
    return 0;
}

 

ABC284E：https://atcoder.jp/contests/abc284/tasks/abc284_e

题意：给定一个无向图找出它的简单路径的条数，然后输出min(ans,1e6)

 

解题思路：dfs回溯找路径比bfs更方便

 

#include<cstdio>//dfs即可
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include <iomanip>
#include<ctime>
using namespace std;
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define TLE (double)clock()/CLOCKS_PER_SEC<=0.95
#define int long long 
#define double long double
#define endl '\n'
#define inf LLONG_MAX
#define iinf INT_MAX
typedef pair<int,int> PII;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 4e5+10;
int n,m,e[N],h[N],ne[N],idx,k;
bool vis[N];
int cnt;
bool flag;
int tmp=1e6;
void add(int a,int b)
{
    e[++idx]=b,ne[idx]=h[a],h[a]=idx;
}
// void bfs(int x)
// {
    // queue<int>q;
    // vis[x]=true;
    // q.push(x);
    // while(!q.empty())
    // {
        // int x=q.front();
        // q.pop();
        // for(int i=h[x];~i;i=ne[i])
        // {
            // int y=e[i];
            // if(!vis[y])
            // {
                // q.push(y);
            // }
            // else cnt++;
        // }
    // }
// }
void dfs(int x)
{
    if(cnt>=tmp)
    {
        flag=true;
        return ;
    }
    vis[x]=true;
    for(int i=h[x];~i;i=ne[i])
    {
        int y=e[i];
        if(!vis[y])    
        {
            ++cnt;
            dfs(y);
            vis[y]=false;
        }
    }
}
signed main()
{
    IOS;
    memset(h,-1,sizeof h);
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u,v);
        add(v,u);
    }
    dfs(1);
    if(!flag)
    cout<<cnt+1<<endl;
    else    cout<<tmp;
//    cout<<min(cnt+1,tmp)<<endl;
    return 0;
}