CSU OJ 代码搜集(1900-2100)

目录

1900: 锋芒不露

1901: 赏赐 OR 灾难

1904: 精灵的交际网

1908: The Big Escape

1909: Perfect Chocolate

1911: Card Game

1912: One Boring Problem

1913: 一条大笨龙送礼物

1914: John and his party

1915: John and his farm

1917: There is no SSR

1919: 不醉不归

1922: Irony Ring

1923: Mysterious Block D

1924: 那些年寮里的崽儿们

1942: Sort String

1947: 突然的灵光

1949: 小明的烦恼

1952: 地下情报员

1954: 吃面包

1956: 数字和

1957: Apache还想再活五百年

1958: 数字游戏

1960: 单源最大权路径

1963: Feed the rabbit

1964: Problem_hc

1965: Message

1968: Permutation Descent Counts

1969: TFSudoku

1971: 安排座位

1972: 大梵天的恩赐

1973: 给自己出题的小X

1974: 神奇药水

1975: 机器人搬重物

1976: 搬运工小明

1977: Bit-reversal Permutation

1978: LXX的图论题

1979: 古怪的行列式

1980: 不堪重负的树

1981: 小M的魔术表演

1982: 小M的移动硬盘

1985: 驱R符

1987: 绚丽的手链

1991: Timo's mushrooms

1993: 大司马的三角形中单

1997: Seating Arrangement

2005: Nearest Maintenance Point

2007: Football Training Camp

2015

2017: Highest Tower

2019: Fleecing the Raffle

2020: Card Hand Sorting

2022: Artwork

2023: Bless You Autocorrect!

2025: Jumbled Compass

2026: Daydreaming Stockbroker

2031: Barareh on Fire

2033: New Country Division

2034: Column Addition

2035: Cafe Bazaar

2036: Getting Back Home

2037: Mars


1900: 锋芒不露

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
int L[105],R[105];
 
int main()
{
    int n;
    int a,b;
    int Max;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0) break;
        memset(L,0,sizeof(L));
        memset(R,0,sizeof(R));
        int lm=100,rm=0;
        for(int k=1;k<=n;k++)
        {
            scanf("%d%d",&a,&b);
            L[a]++;R[b]++;
            if(lm>a) lm=a;
            if(rm<b) rm=b;
            Max=0;
            int i=lm,j=rm;
            int p=L[lm],q=R[rm];
            int match=0;
            while(match!=k)
            {
                if(p==0) {p=L[++i];continue;}
                if(q==0) {q=R[--j];continue;}
                if((i+j)>Max) Max=i+j;
                if(p==q)
                {
                    match+=p;
                    i++;j--;
                    p=L[i];q=R[j];
                }else if(p<q)
                {
                    q-=p;
                    match+=p;
                    p=L[++i];
                }else if(p>q)
                {
                    p-=q;
                    match+=q;
                    q=R[--j];
                }
            }
            printf("%d\n",Max);
        }
        printf("\n");
    }
    return 0;
}

1901: 赏赐 OR 灾难

#include<iostream>
#include<string>
#include<cstdio>
#include<stack>
#include<algorithm>
using namespace std;
const int MAXN=100005;
const int INF=1000000000;
int Min[MAXN];//Min[i]表示前i个宝物中的最小价值
int w[MAXN];
stack<int> s;//单调栈
 
int main()
{
    ios::sync_with_stdio(false);
    int n;
    while(cin>>n)
    {
        while(!s.empty()) s.pop();
        for(int i=1;i<=n;i++)
        {
            cin>>w[i];
            if(i==1) Min[i]=w[i];
            else Min[i]=min(Min[i-1],w[i]);
        }
        bool flag=false;
        s.push(w[n]);
        for(int i=n-1;i>=2;i--)
        {
            int a=Min[i-1];//i左边的最小值
            int c=-1;
            while(!s.empty()&&s.top()<w[i])
            {
                c=s.top();
                s.pop();
            }
            s.push(w[i]);
            if(c>a)
            {
                flag=true;
                break;
            }
        }
        if(flag) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

1904: 精灵的交际网

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=50005;
int fa1[maxn],rel[maxn];
int find1(int x)
{
    if(fa1[x]==x)
      return fa1[x];
    int tem=fa1[x];
    fa1[x]=find1(fa1[x]);
    rel[x]=(rel[x]+rel[tem])%2;
    return fa1[x];
}
 
void merge1(int x,int y)
{
    int fx=find1(x),fy=find1(y);
        fa1[fx]=fy;
      rel[fx]=(rel[y]-rel[x]+1)%2;
}
 
int main()
{
    int T,cnt=0;
    scanf("%d",&T);
    while(T--)
    {
        int n,m,flag1=-1,flag2=0;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
           {
               fa1[i]=i;
               rel[i]=0;
           }
        for(int i=0;i<m;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            if(flag2==1)
                continue;
            if(find1(a)==find1(b))
            {
                if(rel[a]==rel[b]&&flag2==0)
                {
                    flag2++;
                    flag1=i+1;
                }
            }
            else
                merge1(a,b);
        }
       printf("%d\n",flag1);
    }
    return 0;
}

1908: The Big Escape

#include <iostream>
#include<queue>
#include<vector>
#include<algorithm>
#include<functional>
#include<string>
#include<string.h>
#include<cmath>
#include<cstdio>
using namespace std;
const int maxn = 150000+10;
int erear,head[maxn];
int root,n;
int vis[maxn];
int cnt[maxn];
int ans = -1;
int kase = 1;
struct node
{
    int x,to,next;
}E[maxn];
void __init__()
{
    memset(head,-1,sizeof(head));
    erear = 0;
}
void build(int x,int y)
{
    E[erear].x = x;
    E[erear].to= y;
    E[erear].next = head[x];
    head[x] = erear++;
}
int dfs(int root,int &sum)
{
    for(int i = head[root]; i!=-1 ;i = E[i].next)
    {
        if(vis[E[i].to]==0)
        {
            vis[E[i].to] = 1;
            sum++;
            dfs(E[i].to,sum);
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&root))
    {
        __init__();
        ans = 0;
        memset(vis,0,sizeof(vis));
        memset(cnt,0,sizeof(cnt));
        for(int i = 0;i < n-1;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            build(x,y);
            build(y,x);
        }
        vis[root] = 1;
       for(int i = head[root];i!=-1  ;i=E[i].next)
       {
           int sum = 1;
           vis[E[i].to] = 1;
            dfs(E[i].to,sum);
            ans = max(sum,ans);
            /*if(kase == 10003)
            cout<<sum<<endl;*/
 
       }
        cout<<"Case #"<<kase++<<":"<<ans<<endl;
    }
    return 0;
}

1909: Perfect Chocolate

#include <cstdio>
#include <cstring>
 
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
const int MAXN = 1e5 + 5;
const int SIZE = 2e5 + 5;
char S[MAXN];
int main(){
    int cas = 1;
    while(~scanf("%s", S)){
        int len = strlen(S);
        int sum = 0;
        for(int i = 0;i < len;i ++){
            if(S[i] == '1') sum ++;
            else sum --;
        }
        if(sum < 0) sum = -sum;
        if(sum > 0) sum --;
        printf("Case #%d:%d\n",cas ++, sum);
    }
    return 0;
}

1911: Card Game

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
using namespace std;
typedef long long LL;
const int MAXN=1<<18;
int a[MAXN],b[MAXN];
char tmp[20];
 
void FWT(int a[],int n)
{
    for(int d=1;d<n;d<<=1)
        for(int m=d<<1,i=0;i<n;i+=m)
            for(int j=0;j<d;j++)
            {
                int x=a[i+j],y=a[i+j+d];
                //xor:a[i+j]=x+y,a[i+j+d]=(x-y+mod)%mod;
                //and:a[i+j]=x+y;
                a[i+j+d]=x+y;
            }
}
 
void UFWT(int a[],int n)
{
    for(int d=1;d<n;d<<=1)
        for(int m=d<<1,i=0;i<n;i+=m)
            for(int j=0;j<d;j++)
            {
                int x=a[i+j],y=a[i+j+d];
                //xor:a[i+j]=(x+y)/2,a[i+j+d]=(x-y)/2;
                //and:a[i+j]=x-y;
                a[i+j+d]=y-x;
            }
}
 
int main()
{
    int T,cas=0;
    scanf("%d",&T);
    while(T--)
    {
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        int n,m,q;
        scanf("%d%d",&n,&m);
        int tot=1<<m;
        for(int i=0;i<n;i++)
        {
            scanf("%s",tmp);
            int len=strlen(tmp);
            int t=0;
            for(int j=0;j<len;j++)
            {
                t<<=1;
                t|=(tmp[j]-'0');
            }
            a[t]++;
        }
//        for(int i=0;i<=12;i++)
//            cout<<a[i]<<" ";
//        cout<<endl;
        for(int i=0;i<n;i++)
        {
            scanf("%s",tmp);
            int len=strlen(tmp);
            int t=0;
            for(int j=0;j<len;j++){
                t<<=1;
                t|=(tmp[j]-'0');
            }
            b[t]++;
        }
//        for(int i=0;i<=14;i++)
//            cout<<b[i]<<" ";
//        cout<<endl;
        FWT(a,tot); FWT(b,tot);
        for(int i=0;i<tot;++i)
            a[i]=a[i]*b[i];
        UFWT(a,tot);
        scanf("%d",&q);
        printf("Case #%d:\n",++cas);
        while(q--)
        {
            int t=0;
            scanf("%s",tmp);
            int len=strlen(tmp);
            for(int i=0;i<len;i++)
            {
                t<<=1;
                t|=(tmp[i]-'0');
            }
            printf("%d\n",a[t]);
        }
    }
    return 0;
}

1912: One Boring Problem

#include <cstdio>
#include <cstring>
 
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5;
const int SIZE = 2e5 + 5;
const int mod = 1e9 + 7;
LL CC[MAXN];
LL CCD[MAXN];
LL mod_pow(LL x, LL n, LL p){
    LL ret = 1;
    while(n){
        if(n & 1) ret = ret * x % p;
        x = x * x % p;
        n >>= 1;
    }
    return ret;
}
void CC_init(){
    CC[0] = CC[1] = 1;
    CCD[0] = 1;
    CCD[1] = 1;
    for(int i = 2;i < MAXN;i ++){
        CC[i] = CC[i - 1] * i % mod;
        CCD[i] = mod_pow(CC[i], mod - 2, mod) % mod;//乘法逆元
    }
}
 
 
 
LL C(int m, int n, LL p){
    if(m > n) return 0;
    if(n - m < m) m = n - m;
    LL up = 1, down = 1;
    up = CC[n] * CCD[n - m] % p;
    down = CCD[m];
    return up * down % p;
}
 
LL lucas(int m, int n, LL p){
    if(m == 0) return 1;
    return C(m % p, n % p, p) * lucas(m / p, n / p, p) % p;
}
 
int n, m;
 
int main(){
    CC_init();
    while(~scanf("%d%d", &n, &m)){
        LL ans = 0, tmp = 0;
        if(m == 1){
            printf("1\n");
            continue;
        }
        n = n - m;
        for(int i = 1;i <= n;i ++){
            ans = (ans + lucas(m - 1 - 1, n - i + m - 1 - 1, mod)) % mod;//隔板法或者叫做插板法
            //printf("[%d]\n", ans);
            tmp = 0;
            int flag = 1;
            for(int j = 1;j * i + i <= n && j < m;j ++){
                tmp = (tmp + lucas(m - 1 - 1, n - i - j * i + m - 1 - 1, mod) * lucas(j, m - 1, mod) * flag % mod + mod) % mod;
                flag = - flag;
            }
            ans = (ans + mod - tmp) % mod;
        }
        printf("%lld\n", ans);
    }
    return 0;
}

1913: 一条大笨龙送礼物

#include <cstdio>
#include <cstring>
 
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
const int MAXN = 1e5 + 5;
const int SIZE = 2e5 + 5;
int Sum[MAXN * 3], Col[MAXN * 3];
int a[MAXN];
int n, m, k;
struct o {
    int l, r;
} O[MAXN];
void push_up(int rt) {
    Sum[rt] = Sum[rt << 1] + Sum[rt << 1 | 1];
}
void push_down(int rt, int m) {
    if(Col[rt] != -1) {
        Col[rt << 1] = Col[rt << 1 | 1] = Col[rt];
        Sum[rt << 1] = (m - (m >> 1)) * Col[rt];
        Sum[rt << 1 | 1] = (m >> 1) * Col[rt];
        Col[rt] = -1;
    }
}
 
void build(int lowv, int l, int r, int rt) {
    Col[rt] = -1;
    Sum[rt] = 0;
    if(l == r) {
        Sum[rt] = a[l] > lowv;
        return;
    }
    int mid = (l + r) >> 1;
    build(lowv, lson);
    build(lowv, rson);
    push_up(rt);
}
 
void update(int L, int R, int v, int l, int r, int rt) {
    if(L > R) return;
    if(L <= l && r <= R) {
        Sum[rt] = (r - l + 1) * v;
        Col[rt] = v;
        return ;
    }
    push_down(rt, r - l + 1);
    int mid = (l + r) >> 1;
    if(L <= mid) update(L, R, v, lson);
    if(R > mid) update(L, R, v, rson);
    push_up(rt);
}
 
int query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) {
        return Sum[rt];
    }
    int mid = (l + r) >> 1;
    push_down(rt, r - l + 1);
    int ret = 0;
    if(L <= mid) ret += query(L, R, lson);
    if(R > mid) ret += query(L, R, rson);
    return ret;
}
 
bool C(int mid, int len) {
    build(mid, 1, n, 1);
    for(int i = 0; i < len; i ++) {
        int s1 = query(O[i].l, O[i].r, 1, n, 1);
        int s0 = O[i].r - O[i].l + 1 - s1;
        int cz = (s1 & 1) == 1;
        int qlk = s1 / 2;
        update(O[i].l, O[i].l + qlk - 1 + cz, 1, 1, n, 1);
        update(O[i].l + qlk + cz, O[i].r - qlk, 0, 1, n, 1);
        update(O[i].r - qlk + 1, O[i].r, 1, 1, n, 1);
    }
    return query(k, k, 1, n, 1) == 0;
}
 
int main() {
    while(~scanf("%d%d%d", &n, &m, &k)) {
        for(int i = 1; i <= n; i ++) {
            scanf("%d", &a[i]);
        }
        int op, len = 0, zl;
        for(int i = 1; i <= m; i ++) {
            scanf("%d", &op);
            if(op == 1) {
                scanf("%d%d", &O[len].l, &O[len].r);
                len ++;
            } else {
                scanf("%d", &zl);
                len -= zl;
                len = len < 0 ? 0 : len;
            }
        }
        //printf("[%d]\n", len);
        int lb = 0, ub = SIZE;
        while(ub - lb > 1) {
            int mid = (ub + lb) >> 1;
            if(C(mid, len)) ub = mid;
            else lb = mid;
        }
        printf("%d\n", ub);
    }
    return 0;
}

1914: John and his party

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<sstream>
#include<vector>
#include<cmath>
#define LL long long
#define md int mid = (L+R)>>1
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
const int maxn = 2e5+50000;
int id[maxn<<2],mx[maxn<<2];
int n;
int ans[maxn];
int lazy[maxn<<2];
void push_up(int rt)
{
    if(mx[ls]>=mx[rs])
        id[rt] = id[ls];
    else
        id[rt] = id[rs];
    mx[rt] = max(mx[ls],mx[rs]);
}
void push_down(int rt)
{
    if(lazy[rt])
    {
        lazy[ls] += lazy[rt];
        lazy[rs] += lazy[rt];
        mx[ls] += lazy[rt];
        mx[rs] += lazy[rt];
        lazy[rt] = 0;
    }
}
void build(int L,int R,int rt)
{
    if(L==R)
    {
        id[rt] = L;
        mx[rt] = -L;
        return ;
    }
    md;
    build(L,mid,ls);
    build(mid+1,R,rs);
    push_up(rt);
}
void update(int l,int r,int L,int R,int rt)
{
   // cout<<"diap"<<endl;
    if(l<=L&&R<=r)
    {
        lazy[rt]++;
        mx[rt]++;
        return ;
    }
    push_down(rt);
    md;
    if(l<=mid)
        update(l,r,L,mid,ls);
    if(r>mid)
        update(l,r,mid+1,R,rs);
    push_up(rt);
}
void change(int p,int L,int R,int rt)
{
    if(L==R)
    {
        mx[rt] = -0x3f3f3f3f;
       // id[rt] = L;
        return ;
    }
    md;
    push_down(rt);
    if(mid>=p)
        change(p,L,mid,ls);
    else
        change(p,mid+1,R,rs);
    push_up(rt);
 
}
int main()
{
    while(~scanf("%d",&n))
    {
        memset(ans,-1,sizeof(ans));
        build(1,n,1);
        memset(lazy,0,sizeof(lazy));
        for(int i = 0 ;i < n;i++)
        {
            int op,x;
            scanf("%d%d",&op,&x);
            if(!op)
            {
                //cout<<"fuck"<<endl;
                update(1,x,1,n,1);
            //cout<<"gan"<<endl;
            }
            else
                update(x,n,1,n,1);
            if(mx[1]<0)
                continue;
            while(!mx[1])
            {
                ans[id[1]] = i+1;
                change(id[1],1,n,1);
            }
        }
        for(int i = 1;i <= n;i++ )
            printf("%d%c",ans[i],i==n?'\n':' ');
    }
    return 0;
}

1915: John and his farm

#include <queue>
#include <stack>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <string>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
typedef long long LL;
typedef long double LB;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
 
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
 
void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }
 
 
const int MAXN = 1e5 + 5;
const int MAXM = 20;
 
int n, m;
struct Edge {
    int v, next;
} edge[MAXN << 1];
int head[MAXN], tot;
int dep[MAXN], siz[MAXN], fa[MAXN][MAXM];
LL all[MAXN], sum[MAXN];
int root;
 
void init_edge() {
    tot = 0;
    memset(head, -1, sizeof(head));
}
inline void add_edge(int u, int v) {
    edge[tot] = Edge {v, head[u]};
    head[u] = tot ++;
}
void dfs(int u, int pre, int d) {
    int v;
    siz[u] = 1;
    dep[u] = d;
    sum[u] = 0;
    fa[u][0] = pre;
    for(int i = head[u]; ~i; i = edge[i].next) {
        v = edge[i].v;
        if(v == pre) continue;
        dfs(v, u, d + 1);
        siz[u] += siz[v];
        sum[u] += sum[v];
        sum[u] += siz[v];
    }
}
 
void dfs2(int u, int pre) {
    int v;
    for(int i = head[u]; ~i; i = edge[i].next) {
        v = edge[i].v;
        if(v == pre) continue;
        all[v] = all[u] + (n - 1 - siz[v]) - (siz[v] - 1);
        dfs2(v, u);
    }
}
 
void lca_init() {
    for(int j = 1; j < MAXM; ++j) {
        for(int i = 1; i <= n; ++i) {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }
}
 
int lca(int u, int v) {
    while(dep[u] != dep[v]) {
        if(dep[u] < dep[v]) swap(u, v);
        int d = dep[u] - dep[v];
        for(int i = 0; i < MAXM; i++) {
            if(d >> i & 1) u = fa[u][i];
        }
    }
    if(u == v) return u;
    for(int i = MAXM - 1; i >= 0; i--) {
        if(fa[u][i] != fa[v][i]) {
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}
 
int son(int u, int v) {
    while(dep[v] > dep[u] + 1) {
        int w = v;
        for(int j = 0; j < MAXM; ++j) {
            if(dep[fa[v][j]] < dep[u] + 1) break;
            w = fa[v][j];
        }
        v = w;
    }
    return v;
}
 
int main() {
    int u, v, w;
    while(~scanf("%d %d", &n, &m)) {
        init_edge();
        for(int i = 1; i <= n - 1; ++i) {
            scanf("%d %d", &u, &v);
            add_edge(u, v);
            add_edge(v, u);
        }
 
        dfs(root = 1, 0, 0);
        all[root] = sum[root];
        dfs2(root, 0);
 
        lca_init();
        while(m --) {
            scanf("%d %d", &u, &v);
            if(dep[u] > dep[v]) swap(u, v);
            w = lca(u, v);
            int dist, sizu, sizv;
            LL sumu, sumv;
            double ans;
            if(w != u) {
                /** 有lca **/
                dist = dep[u] + dep[v] - 2 * dep[w];
                sizu = siz[u];
                sumu = sum[u];
                sizv = siz[v];
                sumv = sum[v];
            } else {
                /**一条链**/
                dist = dep[v] - dep[u];
                w = son(u, v);
                sizu = n - siz[w];
                sumu = all[u] - sum[w] - siz[w];
                sizv = siz[v];
                sumv = sum[v];
            }
            ans = 1.0 + dist + 1.0 * ((LL)sizu * sumv + (LL)sizv * sumu) / ((LL)sizu * sizv);
            printf("%.8f\n", ans);
        }
    }
    return 0;
}

1917: There is no SSR

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
const int maxn=105;
struct Matrix{
    int n;
    double m[maxn][maxn];
 
    void init(int sz){
        n=sz;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                m[i][j]=0;
    }
    Matrix(int sz){init(sz);}
    void set_I(){
        for(int i=0;i<n;i++) m[i][i]=1.0;
    }
    Matrix operator* (const Matrix& a){
        Matrix ans(n);
        for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++){
            ans.m[i][j]+=m[i][k]*a.m[k][j];
        }
        return ans;
    }
};
int main(){
    double p,q;
    int n,m;
    while(scanf("%lf%lf%d%d",&p,&q,&n,&m)!=EOF){
        Matrix base(n),ans(n);
        for(int i=0;i<n;i++) base.m[i][0]=p*pow(q,i);
        for(int i=0;i<n-1;i++) base.m[i][i+1]=1.0;
 
        ans.m[0][0]=1-pow(q,n);
        for(int i=1;i<n;i++) ans.m[0][i]=1;
 
        m=m-n;
        while(m){
            if(m&1) ans=ans*base;
            m>>=1;
            base=base*base;
        }
        printf("%.6lf\n",1-ans.m[0][0]);
    }
 
}

1919: 不醉不归

#include<iostream>
#include<string.h>
using namespace std;
 
int dp0[500][500],dp1[500][500],s[500][500];
bool mp[500][500];
 
int main()
{
	int N,M,K;
	while (~scanf("%d%d%d",&N,&M,&K)&&N&&M&&K)
	{
		int ans=0;
		memset(mp,0,sizeof(mp));
		memset(dp0,-1,sizeof(dp0));
		memset(dp1,-1,sizeof(dp1));
		for(int i=1;i<=N;i++)
			for(int j=1;j<=M;j++)
			{
				scanf("%d",&s[i][j]);
				s[i][j]+=s[i][j-1];
			}
		int n; scanf("%d",&n);
		while (n--)
		{
			int x,y;
			scanf("%d%d",&x,&y);
			mp[x][y]=1;
		}
		dp0[0][0]=0;
		for(int i=1;i<=N;i++)
		{
			dp0[i][0]=dp0[i-1][0];
			for(int j=1;j<=K&&j<=i*M;j++)
			{
				dp0[i][j]=dp0[i-1][j];
				dp1[i][j]=max(dp0[i][j-1],dp1[i-1][j]);
				for(int k=1,p=1;k<=j&&p<=M;k++)		//k表示在第i个架子花k元钱,p表示目前已经取到第p个瓶子
				for(;p<=M;p++)
					if (mp[i][p])		//当第i个架子的第p个是再来一瓶的瓶子的时候,取完之后有奖码,p可以继续循环而价格不多花钱
					{
						if (dp0[i-1][j-k]>=0) dp1[i][j]=max(dp1[i][j],dp0[i-1][j-k]+s[i][p]);
						//在前i-1个架子中花j-k元,而在第i个架子上花k元刚好取到第p个瓶子,且那个再来一瓶放在之后取
						if (dp1[i-1][j-k+1]>=0) dp1[i][j]=max(dp1[i][j],dp1[i-1][j-k+1]+s[i][p]);
						//在前i-1个架子花j-k+1元且之前没有拿的奖码放在第i个架子上用,所以用j-k+1元就可取p个瓶子
						if (dp0[i-1][j-k+1]>=0) dp0[i][j]=max(dp0[i][j],dp0[i-1][j-k+1]+s[i][p]);							//由于当前遇到了一个再来一瓶,所以我们可以把这个奖码用在前i-1行,相当于在前i-1行可以多1元钱
					} else			//当第i个架子第p个不是再来一瓶的时候
					{
						if (dp0[i-1][j-k]>=0) dp0[i][j]=max(dp0[i][j],dp0[i-1][j-k]+s[i][p]);
						//直接从之前的继承
						if (dp1[i-1][j-k+1]>=0) dp0[i][j]=max(dp0[i][j],dp1[i-1][j-k+1]+s[i][p]);							//把之前的奖码用掉
						p++; break;	//没有再来一瓶,所以处理完毕后就要跳出,得多花钱
					}
			}
			if (i==N) ans=max(ans,max(dp0[i][K],dp1[i][K]));
		}
		printf("%d\n",ans);
	}
	return 0; 
}

1922: Irony Ring

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stack>
using namespace std;
#define LL long long
const int maxn=100010;
struct node
{
    LL r,R,h;
    bool operator<(const node &res)const
    {
        if(R==res.R) return r>res.r;
        else return R>res.R;
    }
}a[maxn];
stack<node> s;
 
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        while(!s.empty()) s.pop();
        for(int i=0;i<n;i++) scanf("%lld%lld%lld",&a[i].r,&a[i].R,&a[i].h);
        sort(a,a+n);
        LL MAX=0,ans=0;
        for(int i=0;i<n;i++)
        {
            while(!s.empty()&&s.top().r>=a[i].R)
            {
                ans-=s.top().h;
                s.pop();
            }
            ans+=a[i].h;
            s.push(a[i]);
            MAX=max(MAX,ans);
        }
        printf("%lld\n",MAX);
    }
    return 0;
} 

1923: Mysterious Block D

#include <queue>
#include <stack>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <string>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
typedef long long LL;
typedef long double LB;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
 
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
 
void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }
 
 
const int MAXN = 111 + 2;
const int HASH_MAX = 1000007;
const int HASH_SIZ = 1e5 + 5;
const int BASE = 131;
struct HashMap {
    struct Edge {
        ULL d[4];
        int next;
        Edge() {}
        Edge(ULL dx[], int nxt) : next(nxt) { for(int i = 0; i < 4; ++i) d[i] = dx[i]; }
    } edge[HASH_SIZ];
    int head[HASH_MAX], tot;
    void hash_init() {
        tot = 0;
        memset(head, -1, sizeof(head));
    }
    bool hash_query(ULL dx[4]) {
        sort(dx, dx + 4);
        ULL x = (dx[0] & dx[1] & dx[2] & dx[3]);
 
        ULL u = x % HASH_MAX;
        for(int i = head[u]; ~i; i = edge[i].next) {
            bool equ = true;
            for(int j = 0; j < 4; ++j) {
                if(dx[j] != edge[i].d[j]) { equ = false; break; }
            }
            if(equ) return true;
        }
        return false;
    }
    ULL hash_add(ULL dx[4]) {
        sort(dx, dx + 4);
        ULL x = (dx[0] & dx[1] & dx[2] & dx[3]);
 
        ULL u = x % HASH_MAX;
        for(int i = head[u]; ~i; i = edge[i].next) {
            bool equ = true;
            for(int j = 0; j < 4; ++j) {
                if(dx[j] != edge[i].d[j]) { equ = false; break; }
            }
            if(equ) return x;
        }
        edge[tot] = Edge(dx, head[u]);
        head[u] = tot ++;
        return x;
    }
 
} hash_xxw;
 
int n, m;
char maze[MAXN][MAXN];
bool vis[MAXN][MAXN];
void dfs(int x, int y, int& xx, int& yy) {
    if(x >= n || y >= m) return;
    if(vis[x][y] || maze[x][y] == '#') return;
    vis[x][y] = true;
    xx = max(x, xx), yy = max(y, yy);
    dfs(x + 1, y, xx, yy);
    dfs(x, y + 1, xx, yy);
}
 
ULL up(int sx, int sy, int tx, int ty) {
    ULL ret = 0;
    for(int i = sx; i <= tx; ++i) {
        for(int j = sy; j <= ty; ++j) {
            ret = ret * BASE + (maze[i][j] == '+');
        }
    }
    return ret;
}
 
ULL right(int sx, int sy, int tx, int ty) {
    ULL ret = 0;
    for(int j = sy; j <= ty; ++j) {
        for(int i = tx; i >= sx; --i) {
            ret = ret * BASE + (maze[i][j] == '+');
        }
    }
    return ret;
}
ULL down(int sx, int sy, int tx, int ty) {
    ULL ret = 0;
    for(int i = tx; i >= sx; --i) {
        for(int j = ty; j >= sy; --j) {
            ret = ret * BASE + (maze[i][j] == '+');
        }
    }
    return ret;
}
ULL left(int sx, int sy, int tx, int ty) {
    ULL ret = 0;
    for(int j = ty; j >= sy; --j) {
        for(int i = sx; i <= tx; ++i) {
            ret = ret * BASE + (maze[i][j] == '+');
        }
    }
    return ret;
}
 
 
int main() {
#ifdef ___LOCAL_WONZY___
    freopen ("input.txt", "r", stdin);
#endif // ___LOCAL_WONZY___
    while(~scanf("%d %d", &n, &m)) {
        memset(vis, false, sizeof(vis));
        for(int i = 0; i < n; ++i) {
            scanf("%s", maze[i]);
        }
        int xx, yy;
        ULL dx[4];
        hash_xxw.hash_init();
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < m; ++j) {
                if(maze[i][j] == '#' || vis[i][j]) continue;
                xx = i, yy = j;
                dfs(i, j, xx, yy);
                dx[0] = up(i, j, xx, yy);
                dx[1] = right(i, j, xx, yy);
                dx[2] = down(i, j, xx, yy);
                dx[3] = left(i, j, xx, yy);
                hash_xxw.hash_add(dx);
            }
        }
        printf("%d\n", hash_xxw.tot);
    }
#ifdef ___LOCAL_WONZY___
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // ___LOCAL_WONZY___
    return 0;
}

1924: 那些年寮里的崽儿们

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
 
 
int main()
{
    int n;
    int u=1;
    while(scanf("%d",&n)!=EOF)
    {
        map<string,int> p;
        string a[100];
        string t;
        int index=0;
        for(int i=0;i<n;i++)
        {
            cin>>t;
            if(p[t])
            {
                p[t]++;
            }else{
               a[index++]=t;
               p[t]++;
            }
        }
        printf("Case %d:\n",u++);
        for(int i=0;i<index;i++)
        {
            cout<<a[i]<<" "<<p[a[i]]<<endl;
        }
    }
    return 0;
}

1942: Sort String

#include <queue>
#include <string>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <map>
 
 
using namespace     std;
 
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ull, ull> puu;
 
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-8)
#define fi first
#define se second
 
//--------------------------
 
const ll mod = 1000000007;
const int maxn = 100010;
 
 
char str[maxn];
int n;
int q;
 
struct Node {
    int left, right;
    int num[26];
    int lazy;
} node[maxn << 2];
 
void push_up(int n) {
    for(int i = 0; i < 26; i++) {
        node[n].num[i] = node[n << 1].num[i] + node[n << 1 | 1].num[i];
    }
}
 
void push_down(int n) {
    if(node[n].lazy != -1) {
        node[n << 1].lazy = node[n << 1 | 1].lazy = node[n].lazy;
        memset(node[n << 1].num, 0, sizeof(node[n << 1].num));
        memset(node[n << 1 | 1].num, 0, sizeof(node[n << 1 | 1].num));
        node[n << 1].num[node[n].lazy] = (node[n].right - node[n].left + 1) - (node[n].right - node[n].left + 1) / 2;
        node[n << 1 | 1].num[node[n].lazy] = (node[n].right - node[n].left + 1) / 2;
        node[n].lazy = -1;
    }
}
 
void update(int n, int left, int right, char val) {
    if(node[n].left >= left && node[n].right <= right) {
        node[n].lazy = val - 'a';
        memset(node[n].num, 0, sizeof(node[n].num));
        node[n].num[node[n].lazy] = node[n].right - node[n].left + 1;
        return ;
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    if(mid >= left)update(n << 1, left, right, val);
    if(mid < right)update(n << 1 | 1, left, right, val);
    push_up(n);
}
 
int query(int n, int left, int right, char val) {
    if(node[n].left >= left && node[n].right <= right) {
        return node[n].num[val - 'a'];
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    int sum = 0;
    if(mid >= left)sum += query(n << 1, left, right, val);
    if(mid < right)sum += query(n << 1 | 1, left, right, val);
    return sum;
}
 
 
void build(int n, int left, int right) {
    node[n].left = left;
    node[n].right = right;
    node[n].lazy = -1;
    if(left == right) {
        node[n].num[str[left] - 'a'] = 1;
        return ;
    }
    int mid = (left + right) >> 1;
    build(n << 1, left, mid);
    build(n << 1 | 1, mid + 1, right);
    push_up(n);
}
 
void print(int n) {
    if(node[n].left == node[n].right) {
        for(int i = 0; i < 26; i++) {
            if(node[n].num[i] != 0) {
                printf("%c", i + 'a');
                break;
            }
        }
        return ;
    }
    push_down(n);
    print(n << 1);
    print(n << 1 | 1);
}
 
void solve() {
    while(~scanf("%d%d", &n, &q)) {
        memset(node, 0, sizeof(node));
        scanf("%s", str + 1);
        build(1, 1, n);
        while(q--) {
            int l, r, op;
            scanf("%d%d%d", &l, &r, &op);
            int num[26] = {0};
            for(int i = 0; i < 26; i++) {
                num[i] = query(1, l, r, i + 'a');
            }
            if(op == 1) {
                for(int i = 0; i < 26; i++) {
                    if(num[i] > 0) {
                        update(1, l, l + num[i] - 1, i + 'a');
                        l += num[i];
                    }
                }
            } else {
                for(int i = 25; i >= 0; i--) {
                    if(num[i] > 0) {
                        update(1, l, l + num[i] - 1, i + 'a');
                        l += num[i];
                    }
                }
            }
        }
        print(1);
        puts("");
    }
 
 
 
}
 
int main() {
#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
#endif
    solve();
    return 0;
}

1947: 突然的灵光

#include<cstdio>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<cstring>
#include<vector>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+100;
LL x[maxn];
LL y[maxn];
LL n;
LL slovey()
{
    LL yy = y[n/2];
    LL sum = 0;
    for(int i = 0 ;i<n;i++)
    {
        sum+=abs(yy-y[i]);
    }
    return sum;
}
LL slovex()
{
    LL xx = x[n/2];
    LL tmp = x[n/2]-1;
    LL sum = 0;
    for(int i = n/2-1;i>=0;i--)
        {
            sum += abs(x[i]-tmp);
            tmp--;
        }
        tmp = x[n/2]+1;
        for(int i = n/2+1;i<n;i++)
        {
            sum+=abs(x[i]-tmp);
            tmp++;
        }
        return sum;
}
int main()
{
    while(~scanf("%lld",&n))
    {
        for(int i = 0 ;i<n;i++)
        {
            scanf("%lld%lld",&x[i],&y[i]);
        }
        sort(x,x+n);
        sort(y,y+n);
        LL sum = 0;
        sum+=slovex();
        sum+=slovey();
        cout<<sum<<endl;
    }
}

1949: 小明的烦恼

#include<iostream>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=1e5+10;
const int maxm=1e7+10;
struct node
{
	int ls,rs,sum;
	int l,r;
}q[maxm];
int a[maxn],father[maxn],root[maxn],s[maxn];
int n,m;
int k;
int build(int l,int r,int d)//建树
{
	k++;
	int t=k;
	q[t].l=l,q[t].r=r;
	if(r<d||l>d)
	{
		q[t].ls=0,q[t].rs=0,q[t].sum=0;
		return t;
	}
	else
	{
		
		q[t].sum=1;	
		if(l==r)
		{
			q[t].ls=0,q[t].rs=0;
		   return t;
		}
		int mid=(l+r)>>1;
		q[t].ls=build(l,mid,d);
		q[t].rs=build(mid+1,r,d);
		
		return t;
	}
} 
int find(int x)
{
	return x==father[x]?x:father[x]=find(father[x]); 
} 
int get(int roots,int ss)//找第k大的数
{
	if(q[roots].l==q[roots].r)
	return q[roots].l;
	int ls=q[roots].ls,rs=q[roots].rs;
	if(q[ls].sum<ss)
	return get(rs,ss-q[ls].sum);
	else
	return get(ls,ss);
}
int merge(int x,int y)//合并
{
	if(q[x].ls==0)
	q[x].ls=q[y].ls;
	else
	{
		if(q[y].ls>0)
		{
			q[x].ls=merge(q[x].ls,q[y].ls);
		}
	}
	if(q[x].rs==0)
	q[x].rs=q[y].rs;
	else
	{
		if(q[y].rs>0)
		{
			q[x].rs=merge(q[x].rs,q[y].rs);
		}
	}
	q[x].sum+=q[y].sum;
	return x;
}
int main()
{
	while(scanf("%d %d",&n,&m)!=EOF)
	{
		int maxl=inf,maxr=0;
		for(int i=1;i<=n;i++)
		{
		 	scanf("%d",&a[i]);
		 	maxl=min(maxl,a[i]);
		 	maxr=max(maxr,a[i]);
		}
		k=0;
		for(int i=1;i<=n;i++)
		{
			father[i]=i;
			s[i]=1;
			root[i]=build(maxl,maxr,a[i]);
		}
		while(m--)
		{
			int x,y;
			int cnd;
			scanf("%d",&cnd);
			if(cnd==2)
			{
				scanf("%d %d",&x,&y);
				int fx=find(x),fy=find(y);
				s[fx]+=s[fy];
				father[fy]=fx;
				root[fx]=merge(root[fx],root[fy]);
			}
			else
			{
				scanf("%d",&x);
				int fx=find(x);
				printf("%d\n",get(root[fx],(s[fx]+1)>>1));
			}
		}
	}
	return 0;
}

1952: 地下情报员

#include<cstdio>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<cstring>
#include<vector>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+100;
char s[maxn];
int n,m;
vector<char>G[maxn];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {scanf("%d%d",&n,&m);
        scanf("%s",s);
        //cout<<s<<endl;
        for(int i = 0;i<n;i++)
        {
            G[i].clear();
 
        }
        for(int i = 0;i<n*m;i++)
        {
            G[i%n].push_back(s[i]);
        }
        for(int i = 0;i<n;i++)
        {
            sort(G[i].begin(),G[i].end());
        }//cout<<s<<endl;
        int sum = 0;
        for(int i = 0;i<n*m;i++)
        {
            int len = G[i%n].size();
            sum+=abs(G[i%n][len/2]-s[i]);
            
        }
        cout<<sum<<endl;
    }
}

1954: 吃面包

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<map>
#include<vector>
#include<sstream>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+10;
long long all,pay1,pay2,cost1,cost2;
 
int main()
{
    while(~scanf("%lld%lld%lld%lld%lld",&all,&pay1,&pay2,&cost1,&cost2))
    {
       if(cost1>cost2)
            swap(cost1,cost2),swap(pay1,pay2);
        LL ans = -1;
       if((all/cost2)<maxn)
       {
           LL num = all/cost2;
            for(int i = 0 ;i<=num;i++)
            {
                LL pre = all - i*cost2;
                ans = max(i*pay2+(pre/cost1)*pay1,ans);
            }
            cout<<ans<<endl;
       }
       else
       {
           LL ans2 = -1;
           for(int i = 0;i <= cost2;i++)
           {
               LL pre = all - i*cost1;
               ans2 = max(i*pay1+(pre/cost2)*pay2,ans2);
           }for(int i = 0;i <= cost1;i++)
           {
               LL pre = all - i*cost2;
               ans2 = max(i*pay2+(pre/cost1)*pay1,ans2);
           }
           cout<<ans2<<endl;
       }
    }
}

1956: 数字和

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
#include<vector>
#include<iostream>
#include<cstdio>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+10;
int a[maxn];
int sum[maxn];
int p1,p2,p3;
int n;
int slove()
{
    p1 = 2;
    p2 = 4;
    p3 = 6;
    for(;p1<=n;p1++)
    {
        p2 = max(p2,p1+2);
        while(p2<=n&&sum[p1-1]>sum[p2-1]-sum[p1]) p2++;
        if(p2>=n||sum[p1-1]<sum[p2-1]-sum[p1])
            continue;
        p3 = max(p3,p2+2);
        while(p3<=n&&sum[p1-1]>sum[p3-1]-sum[p2]) p3++;
        if(p3>=n||sum[p3-1]-sum[p2]>sum[p1-1])
            continue;
        if(sum[n]-sum[p3]==sum[p1-1])
        {
            cout<<p1<<' '<<p2<<' '<<p3<<endl;
            return 41;
        }
    }
    return 0;
}
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i = 1 ;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum[i] = sum[i-1] + a[i];
        }
        if(!slove())
        {
            puts("-1");
        }
    }
}

1957: Apache还想再活五百年

#include<iostream>
#include<string>
#include<map>
#include<set>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<cstring>
#include<iomanip>
#include<sstream>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=1e5;
int y,y2,m,m2,d,d2;
int month[2][13]={{0,31,28,31,30,31,30,31,31,30,31,30,31},
                  {0,31,29,31,30,31,30,31,31,30,31,30,31}};
 
int op(int y)
{
    return (y%100!=0&&y%4==0)||(y%400==0);
}
 
int cal(int y,int m,int d)
{
    int sum=0;
    sum+=y*365;
    for(int i=0;i<y;i++)
    {
        if(op(i)) sum+=1;
    }
    if(op(y))
    {
        for(int i=1;i<m;i++) sum+=month[1][i];
    }else
    {
        for(int i=1;i<m;i++) sum+=month[0][i];
    }
 
    sum+=d;
    return sum;
}
 
int main()
{
    string s;
    int t;
    char ch;
    while(cin>>y)
    {
        cin>>ch;cin>>m;cin>>ch;cin>>d;
        cin>>y2;cin>>ch;cin>>m2;cin>>ch;cin>>d2;
        //cout<<y<<m<<d<<endl;
        //cout<<y2<<m2<<d2<<endl;
        cout<<abs(cal(y,m,d)-cal(y2,m2,d2))<<endl;
    }
    return 0;
}

1958: 数字游戏

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
 
//返回输入值的位数大小
int f(int x)
{
    int num=0,i=1;
    while(x/i)
        {
            num++;
            i*=10;
        }
    return num;
}
 
int main()
{
    int t,x,y;
    cin>>t;
    while(t--)
    {
        cin>>x>>y;
        if(f(x)<f(y)) cout<<"-1"<<endl;    //若x的位数比y的小,直接输出“-1”
        else
            {
                int ans=0,i=f(y),x1,y1;
                for(int j=1; j<i; j++)        //从y最低位开始到次高位停止,记录变换次数
                {
                    x1=x%10;
                    y1=y%10;
                    ans+=abs(y1-x1)<(10-abs(y1-x1))?abs(y1-x1):(10-abs(y1-x1));
                    x/=10;
                    y/=10;
                }
                if(x/10)              //若x位数大于y,则y最高位变换不需考虑前导零的限制条件
                {
                    do                 //直接x将多出来的高位变为零并记录次数
                    {
                        x1=x%10;
                        y1=y%10;
                        ans+=abs(y1-x1)<(10-abs(y1-x1))?abs(y1-x1):(10-abs(y1-x1));
                        x/=10;
                        y/=10;
                    }
                    while(x);
                }
                else                //若x位数等于y,则y最高位变换次数即最高位之差的绝对值
                {
                    x1=x%10;
                    y1=y%10;
                    ans=ans+abs(y1-x1);
                }
                cout<<ans<<endl;
            }
    }
    return 0;
}

1960: 单源最大权路径

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<fstream>
using namespace std;
 
const int INF=0x3f3f3f3f;
const int MAXN=100005;
int dist[MAXN];
bool vis[MAXN];
int n;
 
struct Edge
{
    int v;
    int cost;
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
 
vector<Edge> E[MAXN];
 
void dfs(int start)//点的编号从1开始
{
 
    vis[start]=true;
    for(int i=0;i<E[start].size();i++)
    {
        int v=E[start][i].v;
        int cost=E[start][i].cost;
        if(vis[v]) continue;
        dist[v]=dist[start]+cost;
        dfs(v);
    }
}
 
int main()
{
    int T;
    cin>>T;
    int cas=1;
    while(T--)
    {
        memset(vis,false,sizeof(vis));
        for(int i=1;i<=n;i++) dist[i]=-INF;
        int e;
        cin>>n;
        int s;
        cin>>s;
        e=n-1;
        for(int i=1;i<=n;i++) E[i].clear();
        //for(int i=1;i<=MAXN;i++) dist[i]=INF;
        int u,v,c;
        for(int i=0;i<e;i++)
        {
            int u,v,c;
            cin>>u>>v>>c;
            E[u].push_back(Edge(v,c));
            E[v].push_back(Edge(u,c));
        }
        dist[s]=0;
        dfs(s);
        int ans=-INF;
        for(int i=1;i<=n;i++)
        {
            ans=max(dist[i],ans);
        }
        cout<<"Case #"<<cas++<<": "<<ans<<endl;
    }
    return 0;
}

1963: Feed the rabbit

#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>
#include <string>
#define LL long long
#define ULL unsigned long long
#define mem(a,n) memset(a,n,sizeof(a))
#define fread freopen("in.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)
#define N 100100
#define INF 0x3f3f3f3f
#define eps 1e-9
using namespace std;
LL dis[N],sum[N],dp[110][N],ti[N],que[N];
inline LL dy(int id,int j,int k){
    return dp[id-1][j]+sum[j]-dp[id-1][k]-sum[k];
}
inline LL dx(LL x,LL y){
    return x-y;
}
int main()
{
    ios::sync_with_stdio(false);
    int n,m,p,hole,tim;
    while(cin>>n>>m>>p){
        dis[1]=0;
        for(int i=2;i<=n;++i){
            cin>>dis[i];
            dis[i]+=dis[i-1];
        }
        for(int i=1;i<=m;++i){
            cin>>hole>>tim;
            ti[i]=tim-dis[hole];
        }
        sort(ti+1,ti+m+1);
        for(int i=1;i<=m;++i){
            sum[i]=sum[i-1]+ti[i];
        }
        for(int i=1;i<=m;++i){
            dp[1][i]=ti[i]*i-sum[i];
        }
        for(int i=2;i<=p;++i){
            int frt=0,tail=-1;
            for(int j=1;j<=m;++j){
                while(frt<tail&&dy(i,que[frt+1],que[frt])<
                      ti[j]*dx(que[frt+1],que[frt])){
                    ++frt;
                }
                while(frt<tail&&dy(i,que[tail],que[tail-1])*dx(j,que[tail])>=
                      dy(i,j,que[tail])*dx(que[tail],que[tail-1])){
                        --tail;
                }
                que[++tail]=j;
                int v=que[frt];
                //cout<<dp[i-1][v]<<' '<<sum[v]<<' '<<ti[j]<<' '<<v<<endl;
                dp[i][j]=dp[i-1][v]+sum[v]-ti[j]*v+ti[j]*j-sum[j];
                //printf("i_%d j_%d %lld\n",i,j,dp[i][j]);
            }
        }
        //for(int i=1;i<=p;i++)
        //for(int j=0;j<=m;j++) printf("i_%d j_%d %lld\n",i,j,dp[i][j]);
        cout<<dp[p][m]<<endl;
    }
    return 0;
}

1964: Problem_hc

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
#define N (1<<16)
using namespace std;
 
long long dp[N][16];
int num[N],n;
bool mp[16][16];
vector<int> st[20];
 
int main()
{
    int T_T,T;
    cin>>T_T;T=T_T;
    for(int i=1;i<(1<<16);i++)					//首先预处理出所有状态及对应参加人数
    {
        int status=i,cnt=0;
        while(status)
        {
            if (status&1) cnt++;
            status>>=1;
        }
        num[i]=cnt;
        st[cnt].push_back(i);
    }
    while(T_T--)
    {
        char ch[20];
        scanf("%d",&n);
        int fs=(1<<n)-1;
        for(int i=0;i<n;i++)
        {
            scanf("%s",ch);
            for(int j=0;j<n;j++)
                mp[i][j]=ch[j]-48;
        }
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++) dp[1<<i][i]=1;
        for(int i=1;i<n;i<<=1)						//人数几何增长
        {
            int sz=st[i].size();
            for(int j=0;j<sz&&st[i][j]<=fs;j++)				//枚举参与人数为i的状态
            {
                int st1=st[i][j],x=fs^st1;
                if ((st1&3)==3) continue;				//如果1和2在同一个半区则不行
                for(int k=0;k<n;k++)					//枚举状态st1的获胜者k
                {
                    if (!((1<<k)&st1)) continue;			//k当然要参加
                    for(int st2=x;st2;st2=(st2-1)&x)			//枚举x的所有自己,找合法的st2
                    {
                        if (num[st2]!=i||(st2&3)==3) continue;			//如果参与人数也为i而且1、2不在一个半区,那么合法
                        for(int l=0;l<n;l++)					//枚举st2的获胜者l
                        {
                            if (!((1<<l)&st2)) continue;			//l当然要参加
                            if (mp[k][l]) dp[st1|st2][k]+=dp[st1][k]*dp[st2][l];			//谁获胜方案数就加给谁
                                     else dp[st1|st2][l]+=dp[st1][k]*dp[st2][l];
                        }
                    }
                }
            }
        }
        printf("Case #%d: %lld\n",T-T_T,dp[fs][n-1]);
    }
    return 0;
}

1965: Message

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <map>
 
using namespace std;
 
#define move(a)(1<<(a))
 
typedef long long ll;
typedef pair<int,int>PA;
const int N = 100900;
const int M = 60;
const int INF = 0x3fffffff;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int mod = 1001113;
 
int dp[1<<15][M],dis[M][M];
int st[12];   //存储boss想要哪些员工知道的编号
 
//斯坦纳树:在平面中给你n个点,问你其中m个点到点p的最小生成树,一般n<=10
 
//dp[M个必须知道消息的人组成的状态][到老板或某个员工]:最小花费
//将老板看做0点,最后的答案就是dp[(1<<m)-1][0]
//dp[i][j]的松弛:
//dp[i][j] = min{dp[i][j],dp[k][i]+dp[l][i]},其中k和l是对j的一个划分
//dp[i][j] = min{dp[i][j],dp[i][j']+dist[j'][j]},j与j'有边相连
 
void cal( int n , int m )
{
    //初始化
	for( int sta = 0 ; sta < move(n) ; ++sta ){
		for( int i = 0 ; i <= n+m ; ++i )
			dp[sta][i] = INF;
	}
	for( int i = 0 ; i < n ; ++i ){
		for( int j = 0 ; j <= n+m ; ++j )
            //n个人中的第i个人到第j号人的花费就是st[i]到j间的最小花费
			dp[move(i)][j] = dis[st[i]][j];
	}
 
    //状态松弛
	for( int sta = 1 ; sta < move(n) ; ++sta ){
		//是否有子集
		if( sta&(sta-1) ){
			for( int i = 0 ; i <= n+m ; ++i ){
				for( int j = sta ; j > 0 ; j = (j-1)&sta ){
                    if( dp[sta][i] > dp[sta^j][i]+dp[j][i] )
						dp[sta][i] = dp[sta^j][i]+dp[j][i];
				}
			}
			for( int i = 0 ; i <= n+m ; ++i ){
				for( int j = 0 ; j <= n+m ; ++j )
					if( dp[sta][i] > dp[sta][j]+dis[j][i] )
						dp[sta][i] = dp[sta][j]+dis[j][i];
			}
		}
	}
}
 
void floyed( int n )
{
    for( int k = 0 ; k <= n ; ++k ){
        for( int i = 0 ; i <= n ; ++i ){
            for( int j = 0 ; j <= n ; ++j ){
                dis[i][j] = min( dis[i][j] , dis[i][k]+dis[k][j] );
            }
        }
    }
}
 
int main()
{
//    freopen("1.in","r",stdin);
//    freopen("yuan.out","w",stdout);
    int T;
    scanf("%d",&T);
    while( T-- ){
        memset( dis , -1 , sizeof(dis) );
        int n,m;
        scanf("%d%d",&n,&m);
        for( int i = 1 ; i <= n ; ++i ){
            for( int j = 1 ; j <= n ; ++j ){
                scanf("%d",&dis[i][j]);
            }
        }
        int a,b;
        for( int i = 0 ; i < m ; ++i ){
            scanf("%d%d",&a,&b);
            dis[0][a] = dis[a][0] = b;
            //标记老板想要哪些员工知道消息,老板与这些员工间的连边为花费
            st[i] = a;
        }
        for( int i = 1 ; i <= n ; ++i ){
            if( dis[0][i] == -1 ){
                //对于某些不一定要知道消息的员工,老板与他们间的连边为无穷
                dis[0][i] = dis[i][0] = INF;
            }
        }
        dis[0][0] = 0;
        floyed(n);
        cal(m,n-m);
        printf("%d\n",dp[move(m)-1][0]);
    }
    return 0;
}

1968: Permutation Descent Counts

# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <bitset>
# include <set>
# include <cmath>
# include <algorithm>
using namespace std;
#define lowbit(x) ((x)&(-x))
#define pi acos(-1.0)
#define eps 1e-8
#define MOD 1001113
#define INF 0x3f3f3f3f
#define LL long long
inline int scan() {
    int x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
inline void Out(int a) {
    if(a<0) {putchar('-'); a=-a;}
    if(a>=10) Out(a/10);
    putchar(a%10+'0');
}
#define MX 105
//Code begin...
int dp[MX][MX];
 
void Init()
{
    dp[1][0]=1;
    for (int i=2;i<=100;i++)
    {
        for (int j=0;j<=i-1;j++)
        {
            dp[i][j] = dp[i-1][j]*(j+1)%MOD;
            if (j!=0)
                dp[i][j] = (dp[i][j]+dp[i-1][j-1]*(i-j))%MOD;
        }
    }
}
 
int main()
{
    Init();
    int t = scan();
    while (t--)
    {
        int c = scan();
        int n = scan();
        int m = scan();
        printf("%d %d\n",c,dp[n][m]);
    }
    return 0;
}

1969: TFSudoku

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <math.h>
#include <algorithm>
#include <map>
#include <string>
 
#define INF 0x3f3f3f3f
#define MS(x,y) memset(x, y, sizeof(x))
#define MOD 1000000007
#define LL long long int
 
using namespace std;
 
struct node
{
    int x,y;
}z[10][10];
 
int f[10][10][2][10];//前2维表示第几行第几列。第3维表示格子的上下。第4维表示那些数字不能填,0记录剩余可填的数字数
bool xie[10][10];//记录有斜杠的格子
int T;
 
char s[5];
 
void show()
{
    //printf("*****************************\n");
    for(int i=0;i<6;++i)
    {
        for(int j=0;j<6;++j)
        {
            if(xie[i][j])
            {
                printf("%d/%d ", z[i][j].x, z[i][j].y);
            }
            else
                printf("%d ", z[i][j].x);
        }
        printf("\n");
    }
    //printf("*****************************\n");
}
 
void tian(int a, int b, int x, int y)//填数字,并且把周围的格子出现这个数字的可能性去掉,x表示斜杠上的数字,y表示斜杠下的数字
{
    int xoff = b/3*3;
    int yoff = a/2*2;
    if(x != 0)
    {
        z[a][b].x = x;
        for(int i=0;i<6;++i)
        {
            if(f[a][i][0][x] == 0)
                --f[a][i][0][0];
            f[a][i][0][x] = 1;
            if(f[i][b][0][x] == 0)
                --f[i][b][0][0];
            f[i][b][0][x] = 1;
            if(f[a][i][1][x] == 0)
                --f[a][i][1][0];
            f[a][i][1][x] = 1;
            if(f[i][b][1][x] == 0)
                --f[i][b][1][0];
            f[i][b][1][x] = 1;
        }
        for(int i=0;i<2;++i)
        {
            for(int j=0;j<3;++j)
            {
                if(f[yoff+i][xoff+j][0][x] == 0)
                    --f[yoff+i][xoff+j][0][0];
                f[yoff+i][xoff+j][0][x] = 1;
                if(f[yoff+i][xoff+j][1][x] == 0)
                    --f[yoff+i][xoff+j][1][0];
                f[yoff+i][xoff+j][1][x] = 1;
            }
        }
        if(xie[a][b])
        {
            for(int i=x-1;i>0;--i)
            {
                if(f[a][b][1][i] == 0)
                    --f[a][b][1][0];
                f[a][b][1][i] = 1;
            }
        }
    }
    if(y != 0 && x != y)
    {
        z[a][b].y = y;
        for(int i=0;i<6;++i)
        {
            if(f[a][i][0][y] == 0)
                --f[a][i][0][0];
            f[a][i][0][y] = 1;
            if(f[i][b][0][y] == 0)
                --f[i][b][0][0];
            f[i][b][0][y] = 1;
            if(f[a][i][1][y] == 0)
                --f[a][i][1][0];
            f[a][i][1][y] = 1;
            if(f[i][b][1][y] == 0)
                --f[i][b][1][0];
            f[i][b][1][y] = 1;
        }
        for(int i=0;i<2;++i)
        {
            for(int j=0;j<3;++j)
            {
                if(f[yoff+i][xoff+j][0][y] == 0)
                    --f[yoff+i][xoff+j][0][0];
                f[yoff+i][xoff+j][0][y] = 1;
                if(f[yoff+i][xoff+j][1][y] == 0)
                    --f[yoff+i][xoff+j][1][0];
                f[yoff+i][xoff+j][1][y] = 1;
            }
        }
        if(xie[a][b])
        {
            for(int i=y+1;i<10;++i)
            {
                if(f[a][b][0][i] == 0)
                    --f[a][b][0][0];
                f[a][b][0][i] = 1;
            }
        }
    }
}
 
bool judge()//判断是否得出答案
{
    for(int i=0;i<6;++i)
    {
        for(int j=0;j<6;++j)
        {
            if(xie[i][j])
            {
                if(z[i][j].x == 0 || z[i][j].y == 0)
                    return false;
            }
            else
            {
                if(z[i][j].x == 0)
                    return false;
            }
        }
    }
    return true;
}
 
bool solve()
{
    while(1)
    {
        int x=0,y=0,MIN = 9,ff = 0;
        bool istian = false;
        bool maodun = false;
        for(int i=0;i<6;++i)
        {
            for(int j=0;j<6;++j)
            {
                if(xie[i][j])
                {
                    if(z[i][j].x == 0)
                    {
                        if(f[i][j][0][0] == 0)
                        {
                            maodun = true;
                            //printf("*****(%d,%d)矛盾\n", i, j);
                            break;
                        }
                        else if(f[i][j][0][0] == 1)
                        {
                            for(int ii=1;ii<10;++ii)
                            {
                                if(f[i][j][0][ii] == 0)
                                {
                                    tian(i,j,ii,0);
                                    istian = true;
                                }
                            }
                        }
                        else if(f[i][j][0][0] > 1)
                        {
                            if(f[i][j][0][0] < MIN)
                            {
                                MIN = f[i][j][0][0];
                                x = j;
                                y = i;
                                ff = 0;
                            }
                        }
                    }
                    if(z[i][j].y == 0)
                    {
                        if(f[i][j][1][0] == 0)
                        {
                            maodun = true;
                            //printf("*****(%d,%d)矛盾\n", i, j);
                            break;
                        }
                        else if(f[i][j][1][0] == 1)
                        {
                            for(int ii=1;ii<10;++ii)
                            {
                                if(f[i][j][1][ii] == 0)
                                {
                                    tian(i,j,0,ii);
                                    istian = true;
                                }
                            }
                        }
                        else if(f[i][j][1][0] > 1)
                        {
                            if(f[i][j][1][0] < MIN)
                            {
                                MIN = f[i][j][1][0];
                                x = j;
                                y = i;
                                ff = 1;
                            }
                        }
                    }
                }
                else
                {
                    if(z[i][j].x == 0)
                    {
                        if(f[i][j][0][0] == 0)
                        {
                            maodun = true;
                            //printf("*****(%d,%d)矛盾\n", i, j);
                            break;
                        }
                        else if(f[i][j][0][0] == 1)
                        {
                            for(int ii=1;ii<10;++ii)
                            {
                                if(f[i][j][0][ii] == 0)
                                {
                                    tian(i,j,ii,ii);
                                    istian = true;
                                }
                            }
                        }
                        else if(f[i][j][0][0] > 1)
                        {
                            if(f[i][j][0][0] < MIN)
                            {
                                MIN = f[i][j][0][0];
                                x = j;
                                y = i;
                                ff = 0;
                            }
                        }
                    }
                }
            }
            if(maodun)
                break;
        }
        //show();
        if(maodun)
        {
            //printf("返回\n");
            return false;
        }
        if(!istian)
        {
            if(judge()) return true;
            node tz[10][10];
            int tf[10][10][2][10];
 
            for(int i=0;i<6;++i)
            {
                for(int j=0;j<6;++j)
                {
                    tz[i][j] = z[i][j];
                    for(int k=0;k<2;++k)
                    {
                        for(int m=0;m<10;++m)
                        {
                            tf[i][j][k][m] = f[i][j][k][m];
                        }
                    }
                }
            }
            for(int ii=1;ii<10;++ii)
            {
                if(f[y][x][ff][ii] == 0)
                {
                    //printf("*************假设(%d,%d,%d,%d)\n", y, x, ff, ii);
                    if(y == 3 && x == 1 && ff == 0 && ii == 2)
                        ii = 2;
                    if(ff == 0) tian(y,x,ii,0);
                    else tian(y,x,0,ii);
                    if(solve())
                        return true;
                    for(int i=0;i<6;++i)
                    {
                        for(int j=0;j<6;++j)
                        {
                            z[i][j] = tz[i][j];
                            for(int k=0;k<2;++k)
                            {
                                for(int m=0;m<10;++m)
                                {
                                    f[i][j][k][m] = tf[i][j][k][m];
                                }
                            }
                        }
                    }
                }
            }
            return false;
        }
    }
    return true;
}
 
 
 
int main()
{
    scanf("%d", &T);
    while(T--)
    {
        int CASE;
        scanf("%d", &CASE);
        MS(z, 0);
        MS(f, 0);
        MS(xie, 0);
        for(int i=0;i<6;++i)
        {
            for(int j=0;j<6;++j)
            {
                f[i][j][0][0] = f[i][j][1][0] = 9;
            }
        }
        for(int i=0;i<6;++i)
        {
            for(int j=0;j<6;++j)
            {
                scanf("%s", s);
                int len = strlen(s);
                if(len == 1 && s[0] != '-')
                {
                    tian(i,j,s[0]-'0',s[0]-'0');
                }
                if(len == 3)
                {
                    xie[i][j] = 1;
                    tian(i,j,s[0]=='-'?0:s[0]-'0',s[2]=='-'?0:s[2]-'0');
                }
            }
            int t = 0;
        }
        //show();
        solve();
        printf("%d\n", CASE);
        show();
    }
    return 0;
}

1971: 安排座位

#include<cstdio>
#include<algorithm>
using namespace std; 
 
const int maxn=100005;
int a[maxn],b[maxn];
 
bool cmp(int a,int b)
{
    return a>b;
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i=0;i<n;i++) scanf("%d",a+i);
        for(int i=0;i<n;i++) scanf("%d",b+i);
        sort(a,a+n,cmp);
        sort(b,b+n);
        int ans=0;
        for(int i=0;i<n;i++) ans+=(a[i]-b[i])*(a[i]-b[i]);
        printf("%d\n",ans);
    }
    return 0;
}

1972: 大梵天的恩赐

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
 
typedef long long int LL;
const int maxn=1234567+1;
const int mod=233333333;
int ans[maxn]={0,2};
 
int main()
{
    for(int i=2;i<=1234567;i++)
    {
        ans[i]=(2*ans[i-1]+2)%mod;
    }
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int res1=ans[n];
        int res2=(ans[n]*2-1)%mod;
        printf("%d %d\n",res1,res2);
    }
    return 0;
}

1973: 给自己出题的小X

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=50;
int a[MAXN];
int ans,n;
 
void dfs(int pos,int k,int gap)
{
    if(pos==n||gap<=k+1) return;
    for(int i=pos+1;i<=n;i++)
    {
        if(a[i]-a[pos]>k+1)
        {
            dfs(i,k+1,min(gap,a[i]-a[pos]));
            ans++;
        }
    }
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        ans=0;
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        sort(a+1,a+n+1);
        for(int i=1;i<=n;i++)
            dfs(i,1,INF);
        printf("%d\n",ans);
    }
    return 0;
}

1974: 神奇药水

#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<cmath>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const double eps=1e-6;
const int MAXN=50;
typedef pair<double,double> PDD;
set<PDD> s;
 
 
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        s.clear();
        int op;
        double x,y;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%lf%lf",&op,&x,&y);
            PDD tmp=make_pair(x,y);
            if(op==0)
            {
                if(!s.empty())
                {
                    auto p=s.begin(),q=s.end();q--;
                    if(!s.empty()&&(*p).first<=x&&(*q).first>=x)
                        printf("Yes\n");
                    else printf("No\n");
                }else
                {
                    printf("No\n");
                }
            }else if(op==1)
            {
                s.insert(tmp);
            }else
            {
                auto p=s.find(tmp);
                if(p!=s.end())
                {
                    s.erase(p);
                }
            }
        }
    }
    return 0;
}

1975: 机器人搬重物

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int maxn=55;
char c;
int a[maxn][maxn],n,m,sx,sy,ex,ey,sd;
int dy[4]={1,0,-1,0};
int dx[4]={0,1,0,-1};
bool vis[maxn][maxn][5];
struct node
{
    int x,y,d,step;//用d(0、1、2、3、4)表示不同朝向
    bool operator < (const node &a) const{
        return a.step<step;
    }
};
priority_queue<node> q;
//queue<node> q;
 
bool check(int x,int y)
{
    if(x>=n||y>=m||x<=0||y<=0)
        return false;
    if(a[x][y]==1||a[x+1][y]==1||a[x][y+1]==1||a[x+1][y+1]==1)
        return false;
    return true;
}
 
void bfs()
{
    memset(vis,false,sizeof(vis));
    node now,next;
    now.x = sx;
    now.y = sy;
    now.d = sd;
    now.step = 0;
    if(!check(sx,sy))
    {
        printf("-1\n");
        return ;
    }
    if(!check(ex,ey))
    {
        printf("-1\n");
        return ;
    }
    while(!q.empty()) q.pop();
    q.push(now);
    vis[sx][sy][sd] = true;
    while(!q.empty())
    {
        now = q.top();
        q.pop();
        //printf("%d %d %d %d\n",now.x,now.y,now.d,now.step);
        if(now.x==ex&&now.y==ey)
        {
            printf("%d\n",now.step);
            return ;
        }
        for(int step=1;step<=3;step++)
        {
            next.x = now.x+dx[now.d]*step;
            next.y = now.y+dy[now.d]*step;
            next.d = now.d;
            if(check(next.x,next.y)&&vis[next.x][next.y][next.d]==false)
            {
                next.step = now.step+1;
                q.push(next);
                vis[next.x][next.y][next.d] = true;
            }
            else//如果1 2 3某一个不能走,那后面的肯定不能走
            {
                break;
            }
        }
        if(vis[now.x][now.y][(now.d+1)%4]==false)//ÓÒת
        {
            next.x = now.x;
            next.y = now.y;
            next.d = (now.d+1)%4;
            next.step = now.step+1;
            q.push(next);
            vis[next.x][next.y][next.d] = true;
        }
        if(vis[now.x][now.y][(now.d-1+4)%4]==false)//×óת
        {
            next.x = now.x;
            next.y = now.y;
            next.d = (now.d-1+4)%4;
            next.step = now.step+1;
            q.push(next);
            vis[next.x][next.y][next.d] = true;
        }
    }
    printf("-1\n");
}
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%d\n",&a[i][j]);
            }
        }
        scanf("%d %d %d %d",&sx,&sy,&ex,&ey);
        getchar();
        scanf("%c",&c);
        if(sx==ex&&sy==ey)
        {
            printf("0\n");
            continue;
        }
        if(c=='E') sd=0;
        else if(c=='S') sd=1;
        else if(c=='W') sd=2;
        else if(c=='N') sd=3;
        bfs();
    }
}

1976: 搬运工小明

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
long long a[100010];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int N,M;
        cin>>N>>M;
        memset(a,0,sizeof(a));
        long long maxm=0;
        for(int i=1;i<=M;i++)
        {
            cin>>a[i];
            maxm=a[i]>maxm?a[i]:maxm;
        }
        if(N>=M)
        {
            cout<<maxm<<endl;
            continue;
        }
        while(maxm)
        {
            int cnt=0;
            long long sum=0;
            for(int i=1;i<=M;i++)
            {
                sum=sum+a[i];
                if(sum<maxm)
                {
                    if(i==M)
                    {
                        cnt++;
                        sum=0;
                    }
                    continue;
                }
               else if(sum==maxm)
                {
                    cnt++;
                    sum=0;
                }
               else if(sum>maxm)
                {
                    cnt++;
                    i--;
                    sum=0;
                }
            }
 
            if(cnt<=N)
            {
                cout<<maxm<<endl;
                break;
            }
            else
                maxm++;
        }
    }
    return 0;
}

1977: Bit-reversal Permutation

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
using namespace std;
typedef long long LL;
const int MAXN=2e5+10;
int a[MAXN];
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(a,0,sizeof(a));
        int n;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
        }
        //cout<<log2(100000)<<endl;
        //cout<<pow(2,17)<<endl;
        int t=1;
        int m=0;
        while(t<n)
        {
            t*=2;
            m++;
        }
        //cout<<m<<endl;
        //cout<<(1<<m)<<endl;
        bool flag=true;
        for(int i=0;i<(1<<m);i++)
        {
            //cout<<"-----"<<i<<endl;
            int tmp=i;
            int sum=0;
            for(int j=1;j<=m;j++)
            {
                sum=sum<<1;
                //cout<<"tmp&1:"<<(tmp&1)<<endl;
                sum=sum|(tmp&1);
                tmp=tmp>>1;
                //cout<<"sum: "<<sum<<endl;
            }
            if(!flag) printf(" ");
            else flag=false;
            printf("%d",a[sum]);
            //cout<<sum<<endl;
        }
        printf("\n");
    }
    return 0;
}

1978: LXX的图论题

#include<iostream>
#include<algorithm>
#include<iomanip>
#include<cmath>
using namespace std;
int N,M;
double nmap[505][505];
void init()
{
    for(int i=1;i<N+3;i++)
        for(int j=1;j<N+3;j++)
        nmap[i][j]=10000;
}
int main()
{
    int u,v;
    double w;
    while(cin>>N>>M)
    {
        init();
        bool suc=false;
        for(int i=0;i<M;i++)
        {
            cin>>u>>v>>w;
            nmap[u][v]=min(nmap[u][v],w);  //都是有向边
        }
        for(int i=1;i<=N;i++)
            for(int j=1;j<=N;j++)
            for(int k=1;k<=N;k++)
            {
                if(nmap[j][k]>nmap[j][i]*nmap[i][k])
                    nmap[j][k]=nmap[j][i]*nmap[i][k];
            }
            for(int i=1;i<=N;i++)       //检查有没有环满足条件
                if(nmap[i][i]<1)
                {
                   suc=true;
                   break;
                }
        if(suc)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

1979: 古怪的行列式

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
typedef long long ll;
using namespace std;
const int maxn = 10;
 
int T, n;
ll myints[] = {0,1,2,3,4,5,6,7}, sample[maxn][maxn];
 
ll checkSgn(){ // 计算逆序数。
    int cnt = 0;
    for(int i = 0; i < n-1; i++)
        for(int j = i+1; j < n; j++)
            if(myints[j] < myints[i])
                cnt++;
    if(cnt & 1)
        return -1;
    return 1;
}
 
int main(){
#ifdef TEST
freopen("test.txt", "r", stdin);
#endif // TEST
 
    cin >> T;
    while(T--){
        cin >> n;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                cin >> sample[i][j];
        ll res = 0;
        do{
            ll temp = 1;
            for(int i = 0; i < n; i++){
                temp *= sample[i][myints[i]];
                if(i >= 2)
                if(sample[i][myints[i]] == 82 && sample[i-1][myints[i-1]] == 83 && sample[i-2][myints[i-2]] == 83){
                    temp /= (82*83*83);
                }
            }
            temp *= checkSgn(); // 将一次排列得出的结果乘上1或-1.
            res += temp;
        }while(next_permutation(myints, myints+n));
        cout << res << endl;
    }
 
    return 0;
}

1980: 不堪重负的树

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long LL;
const int maxn=200+5;
const LL INF=1ll<<50;
LL sum[maxn],dp[maxn][maxn],a[maxn],c[maxn];
int n,b[maxn];
 
int main()
{
  int T;
  scanf("%d",&T);
  while(T--)
  {
    scanf("%d",&n);
    for(int i=1;i<=n;++i)scanf("%lld",a+i);
    for(int i=1;i<=n;++i)scanf("%d",b+i);
    for(int i=1;i<=n;++i)c[i]=a[b[i]];
    for(int i=1;i<=n;++i)sum[i]=sum[i-1]+c[i];
 
    for(int i=1;i<=n;++i)
      for(int j=i+1;j<=n;++j)
        dp[i][j]=INF;
 
    for(int i=1;i<=n;++i)dp[i][i]=c[i];
 
    for(int j=2;j<=n;++j)
    {
      for(int i=j-1;i>0;--i)
      {
        dp[i][j]=min(dp[i][j-1],dp[i+1][j])+sum[j]-sum[i-1];
        for(int k=i+1;k<=j-1;++k)
        {
          dp[i][j]=min(dp[i][j],dp[i][k-1]+sum[j]-sum[i-1]+dp[k+1][j]);
        }
      }
    }
    printf("%lld\n",dp[1][n]);
  }
  return 0;
}

1981: 小M的魔术表演

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int MAXN=2e5+5;
int n,m,cnt,root[MAXN],a[MAXN],x,y,k;
 
struct node
{
    int l,r,sum;
}T[MAXN*30];
vector<int> v;
 
int getid(int x)
{
    return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
 
//update(1,n,root[i],root[i-1],getid(a[i]));
void update(int l,int r,int &x,int y,int pos)
{
    T[++cnt]=T[y],T[cnt].sum++,x=cnt;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(mid>=pos) update(l,mid,T[x].l,T[y].l,pos);
    else update(mid+1,r,T[x].r,T[y].r,pos);
}
 
//query(1,n,root[x-1],root[y],k)
int query(int l,int r,int x,int y,int k)
{
    if(l==r) return T[y].sum-T[x].sum;
    int mid=(l+r)>>1;
    int sum=T[T[y].l].sum-T[T[x].l].sum;
    if(mid>=k) return query(l,mid,T[x].l,T[y].l,k);
    else return sum+query(mid+1,r,T[x].r,T[y].r,k);
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        v.clear();
        cnt=0;
        memset(root,0,sizeof(root));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            v.push_back(a[i]);
        }
        sort(v.begin(),v.end());
        v.erase(unique(v.begin(),v.end()),v.end());
        int len=v.size();
        for(int i=1;i<=n;i++)
        {
            update(1,n,root[i],root[i-1],getid(a[i]));
        }
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&k);
            int pos=getid(k);
            //cout<<"pos: "<<pos<<endl;
            if(pos>len)
            {
                printf("%d\n",y-x+1);
            }else
            {
                if(pos==1)
                {
                    printf("0\n");
                }else
                {
                    pos--;
                    printf("%d\n",query(1,n,root[x-1],root[y],pos));
                }
            }
        }
    }
    return 0;
}

1982: 小M的移动硬盘

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
#define MAXN 300010
typedef long long ll;
int m, n;
int l[MAXN], r[MAXN];
void init()
{
	r[0] = 1;
	l[n + 1] = n;
	for (int i = 1; i <= n; i++)
	{
		l[i] = i - 1;
		r[i] = i + 1;
	}
}
void con(int x, int y)
{
	r[x] = y;
	l[y] = x;
}
int main()
{
	int T,x,u,v;
	while (cin >> T)
	{
		while (T--)
		{
			cin >> n >> m;
			init();
			for (int i = 0; i < m; i++)
			{
				cin >> x;
				if (x == 1)
				{
					cin >> u;
					if (r[0] == u)
						continue;
					int l_u = l[u],r_u=r[u],r0=r[0];
					con(l_u, r_u);
					con(u, r0);
					con(0, u);
				}
				else if (x == 2)
				{
					cin >> u;
					if (l[n+1] == u)
						continue;
					int l_u = l[u], r_u = r[u], l_n = l[n+1];
					con(l_u, r_u);
					con(l_n, u);
					con(u, n+1);
				}
				else
				{
					cin >> u >> v;
					if (r[v] == u)
						continue;
					int l_u = l[u], r_u = r[u], r_v = r[v];
					con(l_u, r_u);
					con(u, r_v);
					con(v, u);
				}
			}
			int temp = r[0];
			cout << temp;
			while (r[temp] != (n + 1))
			{
				cout << " " << r[temp];
				temp = r[temp];
			}
			cout << endl;
		}
	}
	return 0;
}

1985: 驱R符

#include<cstdio>
#include<cstring>
#define maxl 50010
 
long long n;
long long f[maxl],dec[maxl];
 
int main()
{
	
	for(long long i=1;i<=50000;i++)
		dec[i]=dec[i-1]+i*(i-1);
	for(long long i=4;i<=50000;i++)
	{
		n=i-3;	
		f[i]=f[i-1]+(n+1)*n/2*n-dec[n];
	}
	int t;
	scanf("%d",&t);
	for(int i=1;i<=t;i++)
	{
		scanf("%lld",&n);
		printf("%lld\n",f[n]);
	}
	return 0;
}

1987: 绚丽的手链

#include <iostream>
#include <cstring>
#include <cstdio>
#include<algorithm>
using namespace std;
int pos, ans;
struct node
{
	int num;
	int child[2];
}tree[10000010];
 
int add()
{
	pos++;
	tree[pos].num = 0;
	for (int i = 0; i<2; i++)
	{
		tree[pos].child[i] = -1;
	}
	return pos;
}
 
int inser(char* str)
{
	int post = 0;
	int tmp = 0;
	int len = strlen(str);
	for (int i = 0; i<len; i++)
	{
		int m = str[i] - '0';
		if (tree[post].child[m] == -1)
		{
			if (tmp == 0)
				tmp = i + 1;
			tree[post].child[m] = add();
		}
 
		post = tree[post].child[m];
		tree[post].num++;
		ans = max(ans, tree[post].num*(i + 1));
	}
	if (!tmp)
		tmp = len;
	return tmp;
}
 
char arr[1000010];
int main()
{
	int T;
	scanf("%d", &T);
	for (int t = 1; t <= T; t++)
	{
		int n;
		pos = 0;
		memset(tree[0].child, -1, sizeof(tree[0].child));
		scanf("%d", &n);
		ans = 0;
		for (int i = 0; i<n; i++)
		{
			scanf("%s", &arr);
			int k = inser(arr);
		}
		cout << ans << endl;
	}
	return 0;
}

1991: Timo's mushrooms

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=100010;
const int maxm=100010;
struct edge_t
{
    int v,next;
}edge[maxm],newedge[maxn];
int Ecnt,newEcnt;
int vertex[maxn],newvertex[maxn];
int Low[maxn],DFN[maxn],Stack[maxn],Belong[maxn];
int Index,top;
int scc;
bool Instack[maxn];
void init_Graph()
{
    Ecnt=newEcnt=0;
    memset(vertex,-1,sizeof(vertex));
    memset(newvertex,-1,sizeof(newvertex));
}
void make_edge(int u,int v)
{
    edge[Ecnt].v=v;
    edge[Ecnt].next=vertex[u];
    vertex[u]=Ecnt++;
}
void make_newedge(int u,int v)
{
    newedge[newEcnt].v=v;
    newedge[newEcnt].next=newvertex[u];
    newvertex[u]=newEcnt++;
}
void Tarjan(int u)
{
    int v;
    Low[u]=DFN[u]=++Index;
    Stack[top++]=u;
    Instack[u]=true;
    for(int i=vertex[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].v;
        if(!DFN[v])
        {
            Tarjan(v);
            if(Low[u]>Low[v]) Low[u]=Low[v];
        }
        else if(Instack[v]&&Low[u]>DFN[v])
            Low[u]=DFN[v];
    }
    if(Low[u]==DFN[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            Instack[v]=false;
            Belong[v]=scc;
        }
        while(v!=u);
    }
}
void solve(int n)
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    Index=scc=top=0;
    for(int i=1;i<=n;i++)
        if(!DFN[i])
           Tarjan(i);
}
int linker[maxn];
bool used[maxn];
bool dfs(int u)
{
    for(int i=newvertex[u];i!=-1;i=newedge[i].next)
    {
        int v=newedge[i].v;
        if(!used[v])
        {
            used[v]=true;
            if(linker[v]==-1||dfs(linker[v]))
            {
                linker[v]=u;
                return true;
            }
        }
    }
    return false;
}
int hungary()
{
    int res=0;
    memset(linker,-1,sizeof(linker));
    for(int u=1;u<=scc;u++)
    {
        memset(used,false,sizeof(used));
        if(dfs(u)) res++;
    }
    return res;
}
//缩点建立新图
void Build_newmap(int n)
{
    for(int u=1;u<=n;u++)
        for(int i=vertex[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].v;
            if(Belong[u]!=Belong[v])
                make_newedge(Belong[u],Belong[v]);
        }
}
int main()
{
    int t;
    int n,m;
    int u,v;
    scanf("%d",&t);
    while(t--)
    {
        init_Graph();
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            make_edge(u,v);
        }
        solve(n);
        Build_newmap(n);
        printf("%d\n",scc-hungary());
    }
    return 0;
}

1993: 大司马的三角形中单

#include<cstdio>
#include<cstring>
#include<algorithm>
 
using namespace std;
 
long long dp[13][10][2],num[13];
 
long long dfs(int len,int x,bool tp,bool lim)
{
    if (len==1) if (tp) return 0; else return 1LL;			//如果len为1,而且居然还是出现了转折点,那么显然转折点是其本身
    if (!lim&&dp[len][x][tp]>-1) return dp[len][x][tp];			//而这显然不合法故返回0,否则返回1有解
    long long res=0;
    if (tp)
    {
        int up=lim?num[len-1]:9;
        for(int i=x+1;i<=up;i++)
            res+=dfs(len-1,i,1,lim&&i==up);
        if (len>2)							//设前一位是转折点的情况,如此len-1必须大于1
            for(int i=x+1;i<=up;i++)
                res+=dfs(len-1,i,0,lim&&i==up);
    } else
    {
        long long up1=x==0?0:x-1;					//如果当前位置已经是0,那么上届是0而不是-1
        int up=lim?min(num[len-1],up1):up1;
        for(int i=0;i<=up;i++)
            res+=dfs(len-1,i,0,lim&&i==num[len-1]);
    }
    if (!lim) dp[len][x][tp]=res;
    return res;
}
 
long long cal(long long n)
{
    long long res=0,len=0;
    memset(dp,-1,sizeof(dp));
    while(n)
    {
        num[++len]=n%10;
        n/=10;
    }
    for(int i=3;i<=len;i++)					//枚举长度
    {
        int up=i==len?num[i]:9;
        for(int j=1;j<=up;j++)					//枚举第一位放的数字
            res+=dfs(i,j,1,i==len&&j==up);
    }
    return res;
}
 
int main()
{
    long long n,m;
    int T_T; scanf("%d",&T_T);
    while(T_T--)
    {
        scanf("%lld%lld",&n,&m);
        printf("%lld\n",cal(m)-cal(n-1));
    }
    return 0;
}

1997: Seating Arrangement

#include<stdio.h>
#include<string.h>
using namespace std;
int main()
{
    int i,j;
    int n,d;
    while(~scanf("%d%d",&n,&d))
    {
        if(d>n/2-1)
            printf("-1\n");
        else
        {
            int t = n/2;
            if(n%2)
                t = t+1;
                 
            for(i = t,j= 1;j<=n;j++)
            {
                if(i!=t) printf(" ");
                printf("%d",i);
                if(j%2) i = i + n/2;
                else i = i - (n/2+1);
            }
            printf("\n");
        }
    } 
    return 0;
} 

2005: Nearest Maintenance Point

#include<cstdio>
#include<cstring>
#include<queue>
#include<bitset>
#include<vector>
#include<algorithm>
#define INF 0x3f3f3f3f
#define N 10100
using namespace std;
 
int d[N],m,n,s,q,a[N],ans[N];
typedef pair<int,int> P;
struct Edge{int y,w;};
vector<Edge> g[N];
bitset<1010> p[N];					//最多1000个关键点,用关键点的序号来对应每一位
 
inline void dijkstra()
{
    priority_queue<P,vector<P>,greater<P> > q;
    for(int i=1;i<=n;i++)
    {d[i]=INF;p[i].reset();}
    for(int i=1;i<=s;i++)				//初始时多个起点,并赋值好bitset的状态
    {
        q.push(P{0,a[i]});
        p[a[i]][i]=1; d[a[i]]=0;
    }
    while (!q.empty())
    {
        int w=q.top().first;
        int j=q.top().second;
        q.pop(); if (w>d[j]) continue;
        for(int k=0;k<g[j].size();k++)
        {
            int y=g[j][k].y;
            int dist=w+g[j][k].w;
            if (d[y]>dist)
            {
                d[y]=dist; p[y]=p[j];			//如果是大于,那么直接赋值覆盖原来的
                q.push(P(d[y],y));
            } else if (d[y]==dist) p[y]|=p[j];		//如果相等,那么用或来继承状态
        }
    }
}
 
int main()
{
    while(~scanf("%d%d%d%d",&n,&m,&s,&q))
    {
        memset(g,0,sizeof(g));
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            g[u].push_back(Edge{v,w});
            g[v].push_back(Edge{u,w});
        }
        for(int i=1;i<=s;i++)
            scanf("%d",&a[i]);
        sort(a+1,a+1+s);				//要求关键点升序输出
        dijkstra();
        while(q--)
        {
            int x,tot=0; scanf("%d",&x);
            for(int i=1;i<=s;i++)
                if (p[x][i]) ans[++tot]=a[i];		//判断对应位置是否能以最短路到达
            for(int i=1;i<tot;i++)
                printf("%d ",ans[i]);
            printf("%d\n",ans[tot]);
        }
    }
    return 0;
}

2007: Football Training Camp

#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
 
#include <time.h>
#include <limits.h>
#include <assert.h>
 
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <vector>
using namespace std;
#define pb push_back
#define vi vector<int>
#define LL long long
#define pi pair<int,int>
#define MEM(a) memset(a,0,sizeof(a));
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define lowbit(x) ((x)&-(x))
#define SI(a) ((a).size())
 
#define MAX 25
#define INF (0x3f3f3f3f)
#define F (1000000007)
int n, maxans, minans;
priority_queue <pi> que;
int main(int argc, char const *argv[])
{
	// freopen("data.in", "r", stdin);
	while (~scanf("%d", &n)) {
		while (!que.empty()) que.pop();
		int tot = 0 , sum = 0;
		Rep(i, n) {
			int score; scanf("%d", &score);
			que.push(make_pair(score, 0));
			sum += score;
		}
 
		minans = INF ,maxans = 0, tot = 0;
		while (1) {
			pi x = que.top();que.pop();
			if (sum % 2 == 0 && 2 * x.first <= sum) {
				maxans = max(maxans,tot+sum/2);
				minans = min(minans,tot+sum/2);
			}
			if(x.first < 3) break;
			 que.push(make_pair(x.first-3,x.second+1));
			 tot++;
			 sum-=3;
		}
		printf("%d %d\n", minans, maxans);
	}
	return 0;
}

2015

同2022

2017: Highest Tower

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<map>
#define LL long long
#define N 500010
using namespace std;
 
vector<int> g[N];
map<int,int> mp;
int n,m,val[N];
LL res,ans;
bool v[N];
 
void dfs(int x,int &edge,int &vertex,int &bi)
{
    v[x]=1;
    edge+=g[x].size()-1;
    vertex++;bi=max(bi,val[x]);
    res+=(LL)val[x]*(g[x].size()-1);
    for(int i=0;i<g[x].size();i++)
        if (!v[g[x][i]]) dfs(g[x][i],edge,vertex,bi);
}
 
int main()
{
    while(~scanf("%d",&n))
    {
        ans=m=0; mp.clear();
        memset(v,0,sizeof(v));
        memset(g,0,sizeof(g));
        for(int i=1;i<=n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            if (!mp[u]) mp[u]=++m,val[m]=u;
            if (!mp[v]) mp[v]=++m,val[m]=v;
            g[mp[u]].push_back(mp[v]);
            g[mp[v]].push_back(mp[u]);
        }
        for(int i=1;i<=m;i++)
            if (!v[i])
            {
                res=0; int edge,vertex,bi;
                dfs(i,edge=1,vertex=0,bi=0);
                if (edge<vertex) res+=(LL)bi; ans+=res;
            }
        printf("%lld\n",ans);
    }
    return 0;
}

2019: Fleecing the Raffle

#include<iostream>
using namespace std;
int main(void)
{
    long long n,p ;
    while(cin>>n>>p)
    {
        double x = n/(p-1);
        double ans = 1;
        ans *= (double)p*x/(n+1);
        for(int i = 2;i <= p+1;++i)
            ans *= (double)(n-p+i)/(n + x -p+i-1);
        printf("%0.8f\n",ans);
    }
   return 0;
}

2020: Card Hand Sorting

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
using namespace std;
 
struct node_t{
    int val;
    int suit;
    int idx;
}p[60];
 
int increas[6],ssort[6];
bool cmp(node_t &a,node_t &b){
    if(a.suit==b.suit)
       return (increas[a.suit]&&a.val<b.val)||(!increas[a.suit]&&a.val>b.val);
    return ssort[a.suit]<ssort[b.suit];
}
 
int Idx[60],flag[6]={0};
int DP[60];
char s[3];
int ans,n;
int S_Int_val(char a){
    if('2'<=a&&a<='9')
        return a-'1';
    if(a=='T') return 9;
    if(a=='J') return 10;
    if(a=='Q') return 11;
    if(a=='K') return 12;
    return 13;
}
 
int S_Int_suit(char a){
    if(a=='s') return 1;
    if(a=='h') return 2;
    if(a=='d') return 3;
    return 4;
}
 
void dfs(int rt){
    if(rt==0){
        sort(p,p+n,cmp);
        for(int i=0;i<n;++i)
            Idx[p[i].idx]=i;
 
        DP[0]=1;
        int maxn=1;
        for(int i=1;i<n;++i){
            DP[i]=1;
            for(int j=0;j<i;++j)
                if(Idx[j]<Idx[i]) DP[i]=max(DP[j]+1,DP[i]);
            maxn=max(maxn,DP[i]);
        }
        ans=min(n-maxn,ans);
 
    }
 
    for(int i=1;i<=4;++i){
        if(flag[i])continue;
        flag[i]=1;
        ssort[rt]=i;
        dfs(rt-1);
        flag[i]=0;
    }
}
 
int main(){
    while(~scanf("%d",&n)){
        for(int i=0;i<n;++i){
            scanf("%s",s);
            p[i].val=S_Int_val(s[0]);
            p[i].suit=S_Int_suit(s[1]);
            p[i].idx=i;
        }
 
        ans=1e9;
        for(int i=0;i<(1<<4);++i){
            for(int j=0;j<4;++j)
                increas[j+1]=((1<<j)&i)?1:0;
            dfs(4);
        }
        printf("%d\n",ans);
    }
 
    return 0;
}

2022: Artwork

#include<cstdio>
#include<cstring>
#include<vector>
#include<set>
#include<queue>
#include<stack>
#include<iostream>
typedef long long ll;
const int N=1e6+10;
using namespace std;
 
int X[4]={0,0,-1,1};
int Y[4]={1,-1,0,0};
 
struct query{int x1,y1,x2,y2;} Q[10010];
 
int n,m,q,f[N],num[1010][1010],p[1010][1010];
int ans[10010],tot=0; bool v[N];
 
int find(int x)
{
	return f[x]==x?x:f[x]=find(f[x]);
}
 
bool check(int x,int y)
{
	if (x<=0||y<=0||x>n||y>m) return 0;
	return 1;
}
 
void work(int x,int y)
{
	tot++;
	f[num[x][y]]=num[x][y];
	for(int k=0;k<4;k++)
	{
		int xx=x+X[k],yy=y+Y[k];
		if (!check(xx,yy)||p[xx][yy]) continue;
		if (find(num[xx][yy])==find(num[x][y])) continue;
		f[find(num[xx][yy])]=find(num[x][y]); tot--;
	}
}
 
int main(){
	int no=0;
	scanf("%d%d%d",&m,&n,&q);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			num[i][j]=++no,f[no]=no;
	for(int i=1;i<=q;i++)
	{
		int x1,y1,x2,y2;
		scanf("%d%d%d%d",&y1,&x1,&y2,&x2);
		if (x1==x2)
		{
			if (y1>y2) swap(y1,y2);
			for(int j=y1;j<=y2;j++) p[x1][j]++;
		} else
		{
			if (x1>x2) swap(x1,x2);
			for(int j=x1;j<=x2;j++) p[j][y1]++;
		}
		Q[i]=query{x1,y1,x2,y2};
	}
 
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			if (p[i][j]) continue;
			for(int k=0;k<4;k++)
			{
				int xx=i+X[k],yy=j+Y[k];
				if (!check(xx,yy)) continue;
				if (p[xx][yy]) continue;
				if (find(num[xx][yy])==find(num[i][j])) continue;
				f[find(num[xx][yy])]=find(num[i][j]);
			}
		}
 
	memset(v,0,sizeof(v));
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			if (p[i][j]) continue;
			int fa=find(num[i][j]);
			if (v[fa]) continue;
			v[fa]=1; tot++;
		}
	ans[q]=tot;
 
	for(int k=q;k>=2;k--)
	{
		if (Q[k].x1==Q[k].x2)
		{
			for(int i=Q[k].y1;i<=Q[k].y2;i++)
				if (!--p[Q[k].x1][i]) work(Q[k].x1,i);
		} else
		{
			for(int i=Q[k].x1;i<=Q[k].x2;i++)
				if (!--p[i][Q[k].y2]) work(i,Q[k].y2);
		}
		ans[k-1]=tot;
	}
	for(int i=1;i<=q;i++)
		printf("%d\n",ans[i]);
	return 0;
}

2023: Bless You Autocorrect!

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#define N 1000010
#define file(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout);
using namespace std;
 
char s[N];
int n,m;
 
struct Trie
{
    struct node{int ch[28],cnt;}T[N];
    int tot,root,d[N]; bool v[N];
    void init(){tot=root=1;}
 
    int newnode()
    {
        ++tot;
        for(int i=0;i<28;i++)
            T[tot].ch[i]=0;
        T[tot].cnt=0;
        return tot;
    }
 
    void ins(char* x)
    {
        int o=root;
        vector<int> point;
        for(int k=0;x[k];k++)
        {
            int c=x[k]-'a';
            if (!T[o].ch[c]) T[o].ch[c]=newnode();
            if (!T[o].ch[26]&&!T[o].cnt) point.push_back(o);
            T[T[o].ch[c]].ch[27]=o; o=T[o].ch[c];
        }
        T[o].cnt++;
        for(int i=0;i<point.size();i++)
            if (point[i]!=root) T[point[i]].ch[26]=o;
    }
 
    void bfs()
    {
        queue<int> q;
        memset(v,0,sizeof(v));
        q.push(root); d[root]=0; v[root]=1;
        while(!q.empty())
        {
            int x=q.front();q.pop();
            for(int i=0;i<28;i++)
            {
                int y=T[x].ch[i];
                if (y==0||v[y]) continue;
                v[y]=1; d[y]=d[x]+1; q.push(y);
            }
        }
    }
 
    int query(char* x)
    {
        int o=root,k;
        for(k=0;x[k];k++)
        {
            int c=x[k]-'a';
            if (T[o].ch[c]==0) break;
            o=T[o].ch[c];
        }
        return d[o]+strlen(x)-k;
    }
} Trie;
 
 
 
 
int main()
{
    //file(x);
    while(cin>>n>>m)
    {
        Trie.init();
        while(n--)
        {
            scanf("%s",s);
            Trie.ins(s);
        }
        Trie.bfs();
        while(m--)
        {
            scanf("%s",s);
            printf("%d\n",Trie.query(s));
        }
        puts("");
    }
    return 0;
}

2025: Jumbled Compass

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
int main(){
    int n,m;
    while(cin>>n>>m){
        int t=m-n;
        if(t<0) t+=360;
        else t=t%360;
        if(t<=360-t) printf("%d\n",t);
        else printf("%d\n",t-360);
    }
    return 0;
}

2026: Daydreaming Stockbroker

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <set>
using namespace std;
int main() {
    int n;
    while(~scanf("%d",&n)) {
        set<long long>se1;
        se1.insert(0);
        long long Map[100002]= {};
        Map[0]=100;
        while(n--) {
            long long temp;
            scanf("%lld",&temp);
            for(set<long long>::iterator it=se1.begin(); it!=se1.end(); it++) {
                long long x=(*it)+Map[(*it)]/temp,y=Map[(*it)]%temp;
                if(x>100000) {
                    y+=(x-100000)*temp;
                    x=100000;
                }
                se1.insert(x);
                Map[x]=max(Map[x],y);
                Map[0]=max(Map[0],Map[(*it)]+(*it)*temp);
            }
        }
        printf("%lld\n",Map[0]);
    }
    return 0;
}

2031: Barareh on Fire

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<iostream>
using namespace std;
const int inf=0x3f3f3f3f;
char s[105][105];
int t[105][105];
int vis[105][105];
int fx[]={1,-1,0,0,1,1,-1,-1};
int fy[]={0,0,1,-1,1,-1,1,-1};
int px[]={1,-1,0,0};
int py[]={0,0,1,-1};
int n,m,k,sx,sy;
struct node
{
    int x,y,step;
}r,p,q;
queue<node> Q;
void bfs_fire()
{
    int i,j;
    while(!Q.empty())
    {
        p=Q.front();
        Q.pop();
        for(i=0;i<8;i++)
        {
            q=p;
            q.x+=fx[i];
            q.y+=fy[i];
            q.step+=k;
            if(q.x<0||q.y<0||q.x>=n||q.y>=m)
                continue;
            if(vis[q.x][q.y]==0)
            {
                vis[q.x][q.y]=1;
                t[q.x][q.y]=q.step;
                Q.push(q);
            }
        }
 
    }
}
int bfs_people()
{
    while(!Q.empty())
        Q.pop();
    memset(vis,0,sizeof(vis));
    int i,j;
    p.x=sx;
    p.y=sy;
    p.step=0;
    vis[p.x][p.y]=1;
    Q.push(p);
    while(!Q.empty())
    {
        p=Q.front();
        Q.pop();
        //printf("%d %d\n",p.x,p.y);
        if(s[p.x][p.y]=='t')
            return p.step;
        for(i=0;i<4;i++)
        {
            q=p;
            q.x+=px[i];
            q.y+=py[i];
            q.step++;
            if(q.x<0||q.y<0||q.x>=n||q.y>=m)
                continue;
            if(vis[q.x][q.y]==0&&q.step<t[q.x][q.y])
            {
                vis[q.x][q.y]=1;
                Q.push(q);
            }
        }
    }
    return -1;
}
 
int main()
{
    int i,j;
    while(scanf("%d %d %d",&n,&m,&k)!=EOF)
    {
        if(n==0&&m==0&&k==0) break;
        memset(t,inf,sizeof(t));
        memset(vis,0,sizeof(vis));
        while(!Q.empty())
            Q.pop();
        for(i=0;i<n;i++)
        {
            scanf("%s",s[i]);
            for(j=0;j<m;j++)
            {
                if(s[i][j]=='f')
                {
                    r.x=i;
                    r.y=j;
                    r.step=0;
                    t[i][j]=0;
                    vis[i][j]=1;
                    Q.push(r);
                }
                if(s[i][j]=='s')
                {
                    sx=i;
                    sy=j;
                }
            }
        }
        bfs_fire();
        int ans=bfs_people();
        if(ans==-1)
            printf("Impossible\n");
        else
            printf("%d\n",ans);
 
    }
}

2033: New Country Division

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<vector>
#include<map>
#include<queue>
#define LL long long
#define N 20010
using namespace std;
 
struct Linear_Basis
{
    LL d[63],p[63],tot;
 
    void init()
    {
        tot=0;
        memset(d,0,sizeof(d));
        memset(p,0,sizeof(p));
    }
 
    bool ins(LL x)
    {
        for(int i=62;i>=0;i--)
            if (x&(1LL<<i))
            {
                if (!d[i]) {d[i]=x;break;}
                x^=d[i];
            }
        return x>0;
    }
 
    LL Max(LL x)
    {
        LL res=x;
        for(int i=62;i>=0;i--)
            res=max(res,res^d[i]);
        return res;
    }
 
} LB;
 
int n,m;
LL w[N];
 
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
	    if (n+m==0) break;
		LB.init();
		memset(w,0,sizeof(w));
		for(int i=1;i<=m;i++)
        {
            int u,v; LL p;
            scanf("%d%d%lld",&u,&v,&p);
            w[u]^=p; w[v]^=p;
        }
        LL P=w[1];
        for(int i=2;i<n;i++)
            LB.ins(w[i]);
        printf("%lld\n",LB.Max(P));
	}
}

2034: Column Addition

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;
char readchar(){
    char cc;
    cc=getchar();
    while(cc=='\n'||cc=='\r'||cc==' '){
        cc=getchar();
    }
    return cc;
}
int a[1010], b[1010], c[1010];
int dp[1010][2], n;
void read(){
    for (int i=0;i<n;++i)
        a[i]=readchar()-'0';
    for (int i=0;i<n;++i)
        b[i]=readchar()-'0';
    for (int i=0;i<n;++i)
        c[i]=readchar()-'0';
    return ;
}
int main(){
    while(scanf("%d",&n)){
        if (n==0)
            break;
        read();
        memset(dp,0,sizeof(dp));
        for (int i=n-1;i>=0;--i){
            if ((a[i]+b[i])%10==c[i]){
                if (a[i]+b[i]>9){
                    dp[i][1]=dp[i+1][0]+1;
                }else{
                    dp[i][0]=dp[i+1][0]+1;
                }
            }
            if (dp[i+1][1]){
                if ((a[i]+b[i]+1)%10==c[i]){
                    if ((a[i]+b[i]+1>9)){
                        dp[i][1]=dp[i+1][1]+1;
                    }else{
                        dp[i][0]=dp[i+1][1]+1;
                    }
                }
            }
            dp[i][1]=max(dp[i+1][1],dp[i][1]);
            dp[i][0]=max(dp[i+1][0],dp[i][0]);
        }
        printf("%d\n",n-dp[0][0]);
    }
    return 0;
}

2035: Cafe Bazaar

#include <cstdio>
#include<map>
#include<algorithm>
#include<cstring>
#include<iostream>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define x first
#define y second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<int, LL>PIL;
typedef pair<LL, int> PLI;
typedef pair<LL, LL> PLL;
const int MX = 1e2 + 5;
const int MXM = MX * 40;
 
vector<PLI>ver;
 
struct Trie {
    int nxt[MXM][2], cnt[MXM];
    int root, rear;
    int new_node() {
        cnt[++rear] = 0;
        memset (nxt[rear], 0, sizeof (nxt[rear]) );
        return rear;
    }
    void init () {
        rear = 0;
        root = new_node();
    }
    void insert (LL x) {
        int now = root, tmp;
        for (int i = 40; i; i--) {
            tmp = x >> (i - 1) & 1;
            if (!nxt[now][tmp]) nxt[now][tmp] = new_node();
            now = nxt[now][tmp];
            cnt[now]++;
        }
    }
    void query() {
        dfs (root, 0, 0, -1);
    }
    void add (LL x, int y) {
        for (int i = y + 1; i <= 40; i++) x <<= 1;
        ver.push_back (PLI (x, y) );
    }
    bool check1 (int now, int d) {
        int now1 = now, now2 = now;
        for (int i = d; i <= 40; i++) {
            if (nxt[now1][0] == 0 || nxt[now2][1] == 0) return 0;
            now1 = nxt[now1][0];
            now2 = nxt[now2][1];
        }
        return 1;
    }
    bool check2 (int now, int d, int s) {
        for (int i = d; i <= 40; i++) {
            if (nxt[now][s] == 0) return 0;
            now = nxt[now][s];
        }
        return 1;
    }
    void dfs (int now, int d, LL val, int s) {
        if (d == 40) {
            add (val, d);
            return;
        }
        if (s == -1) {
            if (check1 (now, d + 1) ) {
                add (val, d);
                return;
            }
            if (nxt[now][0] && nxt[now][1]) {
                dfs (nxt[now][0], d + 1, val << 1, 0);
                dfs (nxt[now][1], d + 1, val << 1 | 1, 1);
            } else if (nxt[now][0]) dfs (nxt[now][0], d + 1, val << 1, -1);
            else dfs (nxt[now][1], d + 1, val << 1 | 1, -1);
        } else {
            if (check2 (now, d + 1, s) ) {
                add (val, d);
                return;
            }
            if (nxt[now][s ^ 1] == 0) add ( val << 1 | (s ^ 1), d + 1), dfs (nxt[now][s], d + 1, val << 1 | s, s);
            else dfs (nxt[now][s ^ 1], d + 1, val << 1 | (s ^ 1), s);
        }
    }
} t;
 
int a[MX], n;
char str[MX];
 
LL code (int l, int r) {
    LL ret = 0, tmp = 0;
    for (int i = l; i <= r; i++) {
        if (str[i] == '.' || i == r) {
            ret = ret * 256 + tmp, tmp = 0;
            continue;
        }
        tmp = tmp * 10 + str[i] - '0';
    }
    return ret;
}
 
bool cmp1 (const PLL& p1, const PLL& p2) {
    if (p1.x != p2.x) return p1.x < p2.x;
    return p1.y > p2.y;
}
bool cmp2 (const PLI& p1, const PLI& p2) {
    return p1.x < p2.x;
}
PLL p[MX];
 
void print (LL x, int y) {
    for (int i = 4; i >= 0; i--) {
        LL tmp = x >> (8 * i) & 255;
        printf ("%lld%c", tmp, i == 0 ? '/' : '.');
    }
    printf ("%d\n", y);
}
 
int main() {
    //freopen ("in.txt", "r", stdin);
    while (~scanf ("%d", &n), n) {
        ver.clear();
        for (int i = 0, j; i < n; i++) {
            scanf ("%s", str);
            int len = strlen (str);
            for (j = 0; j < len; j++) if (str[j] == '-' || str[j] == '/') break;
            LL l, r;
            if (str[j] == '-') {
                l = code (0, j), r = code (j + 1, len);
            } else {
                l = r = code (0, j);
                int cnt = 0;
                for (++j; j < len; j++) cnt = cnt * 10 + str[j] - '0';
                for (int i = cnt + 1; i <= 40; i++) r |= (1LL << (40 - i) );
            }
            p[i] = PLL (l, r);
        }
        sort (p, p + n, cmp1);
        int pre = 0;
        for (int i = 1; i < n; i++) {
            if (p[i].x - 1 <= p[pre].y) p[pre].y = max (p[pre].y, p[i].y);
            else p[++pre] = p[i];
        }
        for (int i = 0; i <= pre; i++) t.init(), t.insert (p[i].x), t.insert (p[i].y), t.query();
        sort (ver.begin(), ver.end(), cmp2);
        printf ("%d\n", ver.size() );
        for (auto f : ver) print (f.x, f.y);
    }
    return 0;
}

2036: Getting Back Home

#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#define N 30010
using namespace std;
 
int d[N],deep[N],n;
vector<int> g[N];
bool v[N];
 
void dfs(int x,int fa,int dep)
{
    d[x]=dep;
    deep[x]=0;
    v[x]=(x==1);
    for(int i=0;i<g[x].size();i++)
    {
        int y=g[x][i];
        if (y==fa) continue;
        dfs(y,x,dep+1); v[x]|=v[y];
        deep[x]=max(deep[x],deep[y]+1);
    }
}
 
void getsub(int x,int fa,int &sub)
{
    int fir=0,sec=0;
    for(int i=0;i<g[x].size();i++)
    {
        int y=g[x][i];
        if (y==fa) continue;
        if (deep[y]+1>fir)
        {
            sec=fir,fir=deep[y]+1;
            sub=max(sec,sub);
        } else
        {
            sec=max(sec,deep[y]+1);
            sub=max(sec,sub);
        }
        getsub(y,x,sub);
    }
}
 
void solve(int x,int fa,int &k,int c)
{
    if (x==1) return;
    if (d[1]-d[x]<k) return;
    int fir=0,sec=0,nxt,z;
    for(int i=0;i<g[x].size();i++)
    {
        int y=g[x][i];
        if (fa==y) continue;
        if (v[y]) {nxt=y;continue;}
        if (deep[y]+1>fir) sec=fir,fir=deep[y]+1,z=y;
                         else sec=max(sec,deep[y]+1);
    }
    int h=d[1]-d[x];
    if (fir)
    {
        int sub=0;
        int tmp=max(c,sec);
        if (tmp<fir)
        {
            getsub(z,x,sub);
            tmp=max(tmp,sub);
            if (tmp) k=max(k,tmp+1);
        } else k=max(k,fir+1);
        k=min(k,h);
    }
    solve(nxt,x,k,max(fir,c)+1);
}
 
int main()
{
    while(~scanf("%d",&n))
    {
        if (n==0) break;
        for(int i=0;i<=n;i++) g[i].clear();
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        dfs(n,0,0);
        int ans=0;
        solve(n,0,ans,0);
        printf("%d\n",ans);
    }
}

2037: Mars

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<vector>
#include<map>
#include<queue>
#define N 20010
using namespace std;
 
struct Suffix_Automation
{
	int tot,cur;
	struct node{int ch[2],len,fa;} T[N];
	void init(){cur=tot=1;memset(T,0,sizeof(T));}
 
	void ins(int x,int id)
	{
		int p=cur;cur=++tot;T[cur].len=id;
		for(;p&&!T[p].ch[x];p=T[p].fa) T[p].ch[x]=cur;
		if (!p) {T[cur].fa=1;return;}int q=T[p].ch[x];
		if (T[p].len+1==T[q].len){T[cur].fa=q;return;}
		int np=++tot; memcpy(T[np].ch,T[q].ch,sizeof(T[q].ch));
		T[np].fa=T[q].fa; T[q].fa=T[cur].fa=np; T[np].len=T[p].len+1;
		for(;p&&T[p].ch[x]==q;p=T[p].fa) T[p].ch[x]=np;
	}
} SAM;
 
struct node{int pos,t,i;};
char s[N],st[N];
int n,m,len,ans;
 
void dfs(int x,int pos,int t)
{
    if (t>=ans) return;
    if (x>=len) return;
    int ch=st[x]-'0';
    int nxt=SAM.T[pos].ch[ch];
    if (nxt==0) ans=min(ans,t);
           else dfs(x+1,nxt,t);
    nxt=SAM.T[pos].ch[ch^1];
    if (nxt==0) ans=min(ans,t+1);
           else dfs(x+1,nxt,t+1);
 
}
 
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		SAM.init();
		if (n+m==0) break;
		scanf("%s",s);
		for(int i=0;s[i];i++)
			SAM.ins(s[i]-'0',i+1);
		while(m--)
		{
			int a,b;
			ans=0x3f3f3f3f;
			scanf("%d %d",&a,&b);
			len=b-a+1; a--; b--;
			for(int i=0;i<len;i++)
				st[i]=s[a+i];
            st[b-a+1]='\0';	dfs(0,1,0);
            if (ans==0x3f3f3f3f) puts("Impossible");
                            else printf("%d\n",ans);
		}
	}
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值