Summer training round2 #10(Training 30)

A:签到题

B!:搜索+DP

#include<bits/stdc++.h>
#define mp make_pair
#define pi pair<int,int>
using namespace std;
const int dx[]={-,,,};
const int dy[]={,,-,};
int f[][][],v[][],a[][],bx,by,ex,ey,n,m,l;
pi q[];
char s[];

void bfs(int k)
{
    int h=,r=;
    for (int i=; i<=n; i++)
        for (int j=; j<=m; j++)
            if (a[i][j])
            {
                q[++r]=mp(i,j);
                v[i][j]=;
            }

    while (h<=r)
    {
        int i=q[h].first,j=q[h].second;
        v[i][j]=; h++;
        for (int w=; w<; w++)
        {
            int x=i+dx[w],y=j+dy[w];
            if (!a[x][y]) continue;
            if (f[x][y][k]>f[i][j][k]+)
            {
                f[x][y][k]=f[i][j][k]+;
                if (!v[x][y])
                {
                    q[++r]=mp(x,y);
                    v[x][y]=;
                }
            }
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=; i<=n; i++)
    {
        scanf("%s",s+);
        for (int j=; j<=m; j++)
        {
            if (s[j]!='#') a[i][j]=;
            if (s[j]=='R')
            {
                bx=i;
                by=j;
            }
            if (s[j]=='E')
            {
                ex=i;
                ey=j;
            }
        }
    }
    scanf("%s",s+);
    l=strlen(s+);
    for (int i=; i<=n; i++)
        for (int j=; j<=m; j++)
            for (int k=; k<=l+; k++) f[i][j][k]=1e9;
    int ans=1e9;
    f[bx][by][]=;
    for (int k=; k<=l+; k++)
    {
        bfs(k-);
        ans=min(ans,f[ex][ey][k-]);
        if (k==l+) break;
        for (int i=; i<=n; i++)
            for (int j=; j<=m; j++)
                if (a[i][j])
                {
                    int pw;
                    if (s[k]=='L') pw=;
                    if (s[k]=='R') pw=;
                    if (s[k]=='U') pw=;
                    if (s[k]=='D') pw=;
                    int x=i+dx[pw],y=j+dy[pw];
                    if (a[x][y]) f[x][y][k]=min(f[i][j][k-],f[x][y][k]);
                    else f[i][j][k]=min(f[i][j][k-],f[i][j][k]);
                    f[i][j][k]=min(f[i][j][k-]+,f[i][j][k]);
                }
    }
    printf("%d\n",ans);
}

C:贪心 每次放尽量右边

#include <bits/stdc++.h>
#define EPS 1.0e-9
#define PI acos(-1.0)
#define INF 30000000
#define MOD 1000000007
#define mem(a,b) memset((a),b,sizeof(a))
#define TS printf("!!!\n")
#define pb push_back
#define pai pair<int,int>
//using ll = long long;
//using ull= unsigned long long;
//std::ios::sync_with_stdio(false);
using namespace std;
//priority_queue<int,vector<int>,greater<int>> que;
typedef pair<int, int> pairint;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = ;
ll mod = 1e9 + ;
int a[maxn];
int num[maxn];
int main()
{
        // freopen("oddfactor.in", "r", stdin);
        // freopen("out.txt", "w", stdout);
        int n,k,r;
        int leftt;
        int rightt;
        leftt=rightt=;
        int anser=;
        int sum=;
        mem(num,);
        cin >> n >> k >> r;
        for(int i=;i<=k;i++)
        {
        scanf("%d",&a[i]);
        num[a[i]]++;
        }
        for(int i=;i<=n;i++)
        {
        if(num[i])
        {
        if(sum)
        leftt=rightt,rightt=i+;
        else
        rightt=i,sum++;
        }
        if(sum==&&i-leftt==r-)
        {
        rightt=i+;
        anser++;
        sum++;
        }
        if(sum==&&i-leftt==r-)
        {
        leftt=rightt;
        rightt=i+;
        anser++;
        }
        }
        cout<<anser<<endl;
        return ;
}

D!:首先假设做题顺序是i1,i2...in，那么最后罚时是n*t(i1)+(n-1)*t(i2)+...t(in)

考虑罚时的期望，根据期望的线性性质，如果第i道题期望在Pi时解决，那么它对期望的贡献就是(n-Pi)*ti

现在求所有可能罚时的总和，也就是我们只要求出每个题目的位置总贡献（(n-Pi)*n!）即可

观察阅读规则，对于每道题什么时候读，我们只要考虑比这道题容易或难的题的数目

所以对第x道题，我们令f[i][j][p][r] 表示有i道比x简单的题还未读，j道比x难的题，p表示x有没有读，r表示当前读过r道比x简单的题，在这种情况下的位置总贡献

（耗时相同的我们随便假定一个难以顺序，因为我们只在乎最后总的贡献）

根据阅读规则很容易写出转移方程，具体见程序

又观察可得，在每个固定状态下，不论是针对哪道题，f[]是不变的即通用的，因此总的复杂度为O(n^3)

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int mo=1e9+;
int f[][][][];
ll d[];
int a[],n,k;

void inc(int &a,int b)
{
    a+=b;
    if (a>mo) a-=mo;
}

int dp(int i,int j,int p,int r)
{
    if (f[i][j][p][r]!=-) return f[i][j][p][r];
    int s=-,rr=r;
    if (i+j+p==) s=k-r; //所有题都读过了
    else if (i+j+p<=n-k) //读过的题超过了k道
    {
        if (r) rr--; //先做最简单的
        else if (p==) s=(i+j+k)*d[i+j]%mo;  //做当前考虑的这道并计算总的贡献
    }
    if (s==-)
    {
        s=; //三种可能的读题情况
        if (i) s=1ll*i*dp(i-,j,p,rr+)%mo;
        if (j) inc(s,1ll*j*dp(i,j-,p,rr)%mo);
        if (p) inc(s,dp(i,j,p-,rr)%mo);
    }
    f[i][j][p][r]=s;
    return s;
}

int main()
{
    memset(f,,sizeof(f));
    d[]=;
    scanf("%d%d",&n,&k);
    for (int i=; i<=n; i++)
        d[i]=d[i-]*i%mo;
    for (int i=; i<=n; i++)
        scanf("%d",&a[i]);
    sort(a+,a+n+);
    int ans=;
    for (int i=; i<=n; i++)
        ans=(ans+1ll*a[i]*dp(i-,n-i,,)%mo)%mo;
    printf("%d\n",ans);
}

E!:

好题，首先求出原先控制区域的凸包

如果把问题一般化处理，就是求凸包插入一个点怎么变

对于每一颗新增点i，凸包面积如果发生变化，一定是从凸包上两点l,r连向i

i-r,i-l两条射线刚好能卡住原凸包，且原先凸包上l~r之间的点不再是边界

根据凸包面积计算公式，如果我们找到l,r，那么很容易用前缀和求出答案

为了寻找l,r，我们假定p1为凸包最左下的点，pm为凸包最右上的点

考虑i的位置，分4种情况

1. i在p1的左侧 2. i在pm的右侧

3. i在p1,pm之间且在p1,pm连线的上方

4. i在p1,pm之间且在p1,pm连线的下方

情况1和情况2类似且较为简单，l,r一定分别在凸包的上凸壳和下凸壳上（也可能正好是p1,pm）

根据i-r,i-l两条射线刚好能卡住原凸包的性质可以用二分快速找到

情况3和情况4显然，l,r会同时落在上凸壳或下凸壳上，我们需要找到一个凸包的分界点k

使得x[k-1]<x[i]<=x[k]，这显然是可以用二分求出的，再在上(下）凸壳的左右区间分别用二分找到l,r即可

示意图如下：

其实，还有一个更简单的方法

可以证明，如果要是新的凸包面积最大，那么增加的点应在整个点集的凸包上

随着点在凸包上的逆时针（或顺时针移动），其对应的l,r也在凸包上做同向移动，由此就是two pointer的问题了

但是写起来似乎很有细节问题，改日把这个方法补上

另外注意这题答案会很大，double精度不够，又答案只有一位小数，直接判断着输出即可

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
struct po
{
    int x,y;
    friend bool operator <(po a,po b)
    {
        if (a.x==b.x) return a.y<b.y;
        return a.x<b.x;
    }
    friend po operator -(po a,po b)
    {
        return (po){a.x-b.x,a.y-b.y};
    }
    friend po operator +(po a,po b)
    {
        return (po){a.x+b.x,a.y+b.y};
    }
    friend ll operator *(po a, po b)
    {
        return 1ll*a.x*b.y-1ll*a.y*b.x;
    }
} p[],q[];
int n,k,t;
ll s[];

int get(int l,int r,int i,int w)
{
    while (l<r)
    {
        int m=(l+r)>>;
        if ((q[m]-p[i])*(q[m+]-p[i])*w>) r=m;
        else l=m+;
    }
    return l;
}

int bord(int l,int r,int i,int w)
{
    while (l<r)
    {
        int m=(l+r)>>;
        if ((q[m].x-p[i].x)*w<) l=m+;
        else r=m;
    }
    return l;
}

int main()
{
    scanf("%d%d",&n,&k);
    for (int i=; i<=n; i++)
        scanf("%d%d",&p[i].x,&p[i].y);
    sort(p+,p++k);
    q[]=p[]; t=;
    for (int i=; i<=k; i++)
    {
        while (t>&&(p[i]-q[t-])*(q[t]-q[t-])>=) t--;
        q[++t]=p[i];
    }
    int m=t;
    for (int i=k-;i;i--)
    {
        while (t>m&&(p[i]-q[t-])*(q[t]-q[t-])>=) t--;
        q[++t]=p[i];
    }
    for (int i=; i<t; i++)
        s[i+]+=s[i]+q[i]*q[i+];
    ll ans=s[t],tmp;
    for (int i=k+; i<=n; i++)
    {
        if (p[i].x<q[].x)
        {
            int l=get(,m,i,), r=get(m,t,i,-);
            tmp=s[r]-s[l]+q[r]*p[i]+p[i]*q[l];
        }
        else if (p[i].x>q[m].x)
        {
            int l=get(,m,i,-),r=get(m,t,i,);
            tmp=s[t]-s[r]+s[l]+q[l]*p[i]+p[i]*q[r];
        }
        else if ((q[m]-q[])*(p[i]-q[])>)
        {
            int mid=bord(m,t,i,-);
            if (mid>m&&(q[mid]-q[mid-])*(p[i]-q[mid-])>) continue;
            int l=mid>m?get(m,mid-,i,-):m;
            int r=get(mid,t,i,);
            tmp=s[t]-s[r]+s[l]+q[l]*p[i]+p[i]*q[r];
        }
        else {
            int mid=bord(,m,i,);
            if (mid>&&(q[mid]-q[mid-])*(p[i]-q[mid-])>) continue;
            int l=(mid>)?get(,mid-,i,-):;
            int r=get(mid,m,i,);
            tmp=s[t]-s[r]+s[l]+q[l]*p[i]+p[i]*q[r];
        }
        ans=max(ans,tmp);
    }
    printf("%lld",ans/);
    if (ans&) puts(".5"); else puts(".0");
}

方法一

F:2-sat问题

#include <bits/stdc++.h>
#define MAXN 10005
using namespace std;
struct TwoSat{
    int dfn[MAXN * ], low[MAXN * ], dfs_ind = , sccno[MAXN * ], scc_cnt = , w[MAXN * ];
    vector<int> G[MAXN * ];
    stack<int> st;
    void Add(int u, int v) {
        G[u].push_back(v);
    }
    void Tarjan(int u)
    {
        dfn[u]=low[u]=dfs_ind++;
        st.push(u);
        for(int i=; i < G[u].size(); i++)
        {
            int v = G[u][i];
            if(!dfn[v])
            {
                Tarjan(v);
                low[u]=min(low[u],low[v]);
            }else if(!sccno[v])
            {
                low[u]=min(low[u],dfn[v]);
            }
        }
        if(dfn[u]==low[u])
        {
            scc_cnt++;
            while(true)
            {
                int x=st.top();st.pop();
                sccno[x]=scc_cnt;
                w[scc_cnt]++;
                if(x==u)break;
            }
        }
    }
    bool Solve(int m) {
        for(int i = ; i <= m * ; i++) {
            if(!dfn[i]) {
                while(!st.empty())st.pop();
                Tarjan(i);
            }
        }
        for(int i = ; i <= m; i++){
            if(sccno[i] == sccno[i + m]) {
                return false;
            }
        }
        return true;
    }
}twosat;
int n, r, l, x[MAXN], y[MAXN];
int main() {
    scanf("%d%d%d", &n, &r, &l);
    for(int i = ; i <= l; i++) {
        scanf("%d%d", &x[i], &y[i]);
    }
    for(int i = ; i <= l; i++) {
        for(int j = ; j <= l; j++) {
            if(i == j) continue;
            if(x[i] == x[j] && abs(y[i] - y[j]) <=  * r) {
                twosat.Add(i + l, j);
                twosat.Add(j + l, i);
            }
            if(y[i] == y[j] && abs(x[i] - x[j]) <=  * r) {
                twosat.Add(i, j + l);
                twosat.Add(j, i + l);
            }
        }
    }
    if(twosat.Solve(l)) {
        printf("YES\n");
    }else {
        printf("NO\n");
    }
    return ;
}

G!:首先把确定的拎出来，不确定的地方要使海岛尽可能多，那必定是将一格作为一个海岛

不难想到将图黑白染色做而二分图的最大独立集

#include<bits/stdc++.h>

using namespace std;
const int dx[]={-,,,};
const int dy[]={,,-,};
char s[];
int f[],b[][],a[][],v[][],cy[],cx[],n,m,ans,t;
vector<int> g[];
void dfs(int i,int j)
{
    v[i][j]=;
    for (int k=; k<; k++)
    {
        int x=i+dx[k],y=j+dy[k];
        if (x==||x>n||y>m||y==) continue;
        if (v[x][y]) continue;
        if (a[x][y]==-) a[x][y]=;
        if (a[x][y]==) dfs(x,y);
    }
}

int work(int x)
{
    for (int i=; i<g[x].size(); i++)
    {
        int y=g[x][i];
        if (!f[y])
        {
            f[y]=;
            if (!cy[y]||work(cy[y]))
            {
                cx[x]=y;
                cy[y]=x;
                return ;
            }
        }
    }
    return ;
}

int main()
{
    //freopen("1.in","r",stdin);
    scanf("%d%d",&n,&m);
    for (int i=; i<=n; i++)
    {
        scanf("%s",s+);
        for (int j=; j<=m; j++)
        {
            if (s[j]=='W') a[i][j]=;
            if (s[j]=='C') a[i][j]=-;
            if (s[j]=='L') a[i][j]=;
        }
    }
    for (int i=; i<=n; i++)
        for (int j=; j<=m; j++)
            if (!v[i][j]&&a[i][j]==)
            {
                ans++;
                dfs(i,j);
            }

    for (int i=; i<=n; i++)
        for (int j=; j<=m; j++)
            if (a[i][j]==-) b[i][j]=++t;
    for (int i=; i<=n; i++)
        for (int j=; j<=m; j++)
            if ((i+j)%==)
            {
                for (int k=; k<; k++)
                {
                    int x=i+dx[k],y=j+dy[k];
                    if (b[x][y]) g[b[i][j]].push_back(b[x][y]);
                }
            }
    int s=;
    for (int i=; i<=t; i++)
        if (g[i].size())
        {
            if (!cx[i])
            {
                memset(f,,sizeof(f));
                s+=work(i);
            }
        }
    printf("%d\n",ans+t-s);
}

H:离散化后DP ans[i]表示取i个最少要漏掉多少个 不取的话就直接duan[i].r-duan[i-1].r取的话就duan[i].l-duan[cur].r-1

#include <bits/stdc++.h>
#define EPS 1.0e-9
#define PI acos(-1.0)
#define INF 30000000
#define MOD 1000000007
#define mem(a,b) memset((a),b,sizeof(a))
#define TS printf("!!!\n")
#define pb push_back
#define pai pair<int,int>
//using ll = long long;
//using ull= unsigned long long;
//std::ios::sync_with_stdio(false);
using namespace std;
//priority_queue<int,vector<int>,greater<int>> que;
typedef pair<int, int> pairint;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = ;
ll mod = 1e9 + ;
struct node
{
 ll l;
 ll r;
}duan[maxn];
ll righ[maxn];
ll ans[maxn];
ll getit[maxn];
bool cmp(node a,node b)
{
 return b.r>a.r;
}
int main()
{
        // freopen("oddfactor.in", "r", stdin);
        // freopen("out.txt", "w", stdout);
        ll n,m;
        ll anser;
        ll cur;
        cin >> n >> m;
        for(int i=;i<=m;i++)
        scanf("%lld %lld",&duan[i].l,&duan[i].r);
        sort(duan+,duan++m,cmp);
        ll now=;
        for(int i=;i<=m;i++)
        righ[i]=duan[i].r;
        for(int i=;i<=m;i++)
        {
        cur=lower_bound(righ+,righ++m,duan[i].l)-righ-;
        ans[i]=min(ans[cur]+duan[i].l-duan[cur].r-,ans[i-]+duan[i].r-duan[i-].r);
        }
        cout<<n+ans[m]-duan[m].r;
        return ;
}

I:贪心 每次肯定送尽可能最远的最优

#include<math.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<sstream> //istringstream stm(string); stm >> x;
#include<vector>
#define INF 2139062143
#define inf -2139062144
#define ll long long
using namespace std;
struct point {
    ll pos,letter;
};
bool cmp(point p1, point p2) {
    return p1.pos < p2.pos;
}
vector<point> pzheng,pfu;
int main() {
    ll n,k,i,j;
    scanf("%lld%lld",&n,&k);
    for(i=; i<n; i++) {
        ll pos,x;
        scanf("%lld%lld",&pos,&x);
        if(pos >= ) {
            pzheng.push_back({pos,x});
        } else {
            pfu.push_back({-pos,x});
        }
    }
    sort(pzheng.begin(),pzheng.end(),cmp);
    sort(pfu.begin(),pfu.end(),cmp);
//    for(i=0;i<pzheng.size();i++){
//        printf("%lld %lld\n",pzheng[i].pos,pzheng[i].letter);
//    }
    bool over = false;
    ll size = pzheng.size();
    ll cur = size - ;
    ll ans = ;
    if(size > ) {
        while(!over) {
            if(pzheng[cur].letter > k) {
                ll time = pzheng[cur].letter / k;
                ans += time * pzheng[cur].pos * ;
                pzheng[cur].letter -= time * k;
                if(pzheng[cur].letter == )    cur--;
            } else {
                ll send = k;
                ans +=  * pzheng[cur].pos;
                while(send >  && cur >= ) {
                    ll last = pzheng[cur].letter;
                    pzheng[cur].letter = max((ll),pzheng[cur].letter - send);
                    send -= (last - pzheng[cur].letter);
                    if(send >  || pzheng[cur].letter == ) {
                        cur--;
                    }
                }
            }
            if(pzheng[].letter ==  || cur < ) {
                over = true;
            }
        }
    }

    over = false;
    size = pfu.size();
    if(size > ) {
        cur = size - ;
        while(!over) {
            if(pfu[cur].letter > k) {
                ll time = pfu[cur].letter / k;
                ans += time * pfu[cur].pos * ;
                pfu[cur].letter -= time * k;
                if(pfu[cur].letter == )    cur--;
            } else {
                ll send = k;
                ans +=  * pfu[cur].pos;
                while(send >  && cur >= ) {
                    ll last = pfu[cur].letter;
                    pfu[cur].letter = max((ll),pfu[cur].letter - send);
                    send -= (last - pfu[cur].letter);
                    if(send >  || pfu[cur].letter == ) {
                        cur--;
                    }
                }
            }
            if(pfu[].letter ==  || cur < ) {
                over = true;
            }
        }
    }

    printf("%lld\n",ans);
    return ;
}

J:2016年网络赛题

#include <bits/stdc++.h>
#define EPS 1.0e-9
#define PI acos(-1.0)
#define INF 30000000
#define MOD 1000000007
#define mem(a,b) memset((a),b,sizeof(a))
#define TS printf("!!!\n")
#define pb push_back
#define pai pair<int,int>
//using ll = long long;
//using ull= unsigned long long;
//std::ios::sync_with_stdio(false);
using namespace std;
//priority_queue<int,vector<int>,greater<int>> que;
typedef pair<int, int> pairint;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = ;
int n,m;
ll aaa[maxn][];
ll a[maxn];
void init()
{
 for(int i=;(<<i)<=n;i++)
        for(int j=;j<=n-(<<i)+;j++)
 {
        aaa[j][i]=min(aaa[j][i-],aaa[j+(<<(i-))][i-]);
 }
}
ll runit(int l,int r)
{
 int now;
 for(now=;(<<now)<=r-l+;now++);
 now--;
 ll ans=min(aaa[l][now],aaa[r-(<<now)+][now]);
 return ans;
}
int cal(ll value,int x,int y)
{
 if(x>y)
 return ;
 if(value>a[x])
 return x;
 if(x==y)
 return ;
 if(value<runit(x,y))
 return ;
 int l=x,r=y,mid;
 while(r-l>)
 {
        mid=(l+r)/;
        if(value>=runit(x,mid))
        r=mid;
        else
        l=mid;
 }
 return r;
}
ll work(ll pop,int pop1,int pop2)
{
 int flag=;
 while(flag)
 {
        pop%=a[pop1];
        int now=cal(pop,pop1+,pop2);
        if(!now)
        return pop;
        else
        pop1=now;
 }
}
int main()
{
    cin >> n >> m;
    for(int i=;i<=n;i++)
    {
        scanf("%I64d",&a[i]);
        aaa[i][]=a[i];
    }
    init();
    while(m--)
    {
        ll cur,l,r;
        scanf("%I64d %I64d %I64d",&cur,&l,&r);
        //cin >> cur >> l >> r
        //cout<<cur<<" "<<l<<" "<<r<<endl;
        printf("%I64d\n",work(cur,l,r));
    }
    return ;
}