absi2011
一个新的开始吧w 希望这一次能如我所愿w
Topcoder Open 3A (TCO 3A)

开场开250,然后直接交了一发,247分还可以

然后开500,发现是一个很复杂的计算,经过30+分钟终于码掉了

最后开1000,发现不会做 && 大家过了一片...

challenge阶段,觉得250输入2,11能cha一片结果没cha到人

相反,看到一个人4 11输出Bob直接就cha上去了

当然结果.............-25

而且cha了两个,也就是说-50

然后

500fst了真开心

===================================

250

A和B轮流写一个数,然后一共写出一个length位数

A第一位不可以写0

如果这个数是divisor的倍数,那么B赢,不然A赢

问A和B谁能赢?

 

1 <= length <= 1000

1 <= divisor <= 1000

 

500

给你一个长度为n的序列a

问有多少个子串,使得其中的积小于limit?

由于这是tc,n又范围要到100000,所以给了你一个数据生成器

最多手动构造500个数,后面的由生成器构造

数据范围:

n<=105

|ai|<=109

0 < limit <=109

 

1000

给你一个图,每个点度都为3

问你一个01染色方案,使得不存在一个环是同色的

4<=n<=1000,n为偶数

 

=================================

250

divisor==1 显然Bob赢

否则 length为奇数,Alice赢,理由:

最后一步归Alice

如果放1是divisor的倍数就放2,否则放1就行

否则 divisor>=12 Alice赢,理由:

倒数第二步归Alice

12*4=48,12*5=60

在6个中就有一个选项,让Bob没法放

13是13*4=52

14,15之后就更快了,越来越多的选项让Bob没法放

(不是很会表述QAQ)

否则 divisor <=10 Bob赢

理由:

前面的部分(要乘过10)%divisor = x,最后一个直接补一个divisor-x就好

例如:

4_ % 7

40%7 = 5, 7-5=2

补2即可

=======================

divisor = 11的情况很有趣,也是Bob赢

A放什么,B就放什么,所以这两个数就一定是11的倍数

所以B赢

=======================

虽然这题可以dp,不过如果length和divisor大一点还是可以这么做的

 

 

500

情况一大堆

首先先考虑0

____ 0 ____ 0 ___ 0 ____

带0的肯定都符合条件,直接统计?

大概需要一些小技巧不重复的把带0的统计好

比如对于第一个0,统计所有带第一个零的有多少个,直接乘法就可以处理

然后第二个0,我们统计所有带第二个,不带第一个零(也不带它左边的任何数)有多少个,直接乘法

这样下去,我们就把这个问题分成了一些小段

================================

然后我们考虑

由于230>109,我们知道除了1和-1以外,一共乘最多30次,这样不会T

那么我们要特殊处理下1和-1的情况,所以又要写一大堆代码.......

大概类似一个链表一样的..然后暴力....细节挺多的也不知道怎么表达....

不多吐槽...........

然后还要处理负数..所有的负数都是满足条件的,我们要写个dp.......

相比于1000,我为啥不把1000想出来A掉...........

 

 

1000

直接dfs,有一颗dfs树

我们把树上的边染成1,树外的染成0就行

我们只要证明,不会有树外的环就行,也就是所有的环都包含一条树边

一个环,肯定不能只有入边,没有出边,所以这个环上的点剩余度数应该是2,所以只可能所有的叶子和根是这样的

那么一个叶子如果连到另外一个叶子,那么这根本不是一个dfs树,因为这个叶子会继续dfs下去的,只可能是返祖边

所以不存在这么一个环........

 

代码:

250

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<string>
#include<time.h>
#include<math.h>
#include<memory>
#include<vector>
#include<bitset>
#include<fstream>
#include<stdio.h>
#include<utility>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<algorithm>
using namespace std;
struct LeftToRightGame
{
    string whoWins(int length, int divisor)
    {
        if (divisor==1)
        {
            return "Bob";
        }
        if ((divisor==11)&&(length%2==0)) 
        {
            return "Bob";
        }
        else if ((divisor<=10)&&(length%2==0))
        {
            return "Bob";
        }
        else
        {
            return "Alice";
        }
    }
};
#ifdef absi2011
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    
    return 0;
}
#endif

500

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<string>
#include<time.h>
#include<math.h>
#include<memory>
#include<vector>
#include<bitset>
#include<fstream>
#include<stdio.h>
#include<utility>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<algorithm>
using namespace std;
int a[100005];
int b[100005];
int next_valid[100005];
int sgn[100005];
int pos[100005],neg[100005];
long long dp[100005][2];
long long solve2(int n,int limit)
{
    b[n]=0;
    int i;
    next_valid[n]=n;
    for (i=n-1;i>=0;i--)
    {
        if ((b[i]==1)||(b[i]==-1))
        {
            next_valid[i]=next_valid[i+1];
        }
        else
        {
            next_valid[i]=i;
        }
    }
    pos[n]=0;
    neg[n]=0;
    sgn[n]=1;
    for (i=n-1;i>=0;i--)
    {
        pos[i]=1;
        neg[i]=0;
        sgn[i]=1;
        if (b[i+1]==1)
        {
            pos[i]=pos[i+1]+1;
            neg[i]=neg[i+1];
            sgn[i]=sgn[i+1];
        }
        else if (b[i+1]==-1)
        {
            pos[i]=neg[i+1]+1;
            neg[i]=pos[i+1];
            sgn[i]=-sgn[i+1];
        }
        else
        {
            continue;
        }
    }
    long long ans=0;
    for (i=0;i<n;i++)
    {
        long long p=b[i];
        int now=i;
        for (;;)
        {
            if ((p>limit)||(p<-limit)) break;
            if (p>0)
            {
                ans+=pos[now];
            }
            else
            {
                ans+=neg[now];
            }
            p*=sgn[now];
            now=next_valid[now+1];
            if (now==n) break;
            p*=b[now];
        }
    }
    for (i=0;i<=n;i++)
    {
        dp[i][0]=0;
        dp[i][1]=0;
    }
    for (i=0;i<n;i++)
    {
        if (b[i]<0)
        {
            dp[i+1][0]=dp[i][1];
            dp[i+1][1]=dp[i][0]+1;
        }
        else
        {
            dp[i+1][0]=dp[i][0]+1;
            dp[i+1][1]=dp[i][1];
        }
        ans+=dp[i+1][1];
    }
    return ans;
}
long long solve(int n,int limit)
{
    int i;
    long long ans=0;
    int last_zero=-1;
    for (i=0;i<n;i++)
    {
        if (a[i]==0)
        {
            ans=ans+(long long)(i-last_zero)*(n-i);
            last_zero=i;
        }
    }
    last_zero=0;
    for (i=0;i<n;i++)
    {
        if (a[i]==0)
        {
            //(last_zero,i)
            memcpy(b,a+last_zero,sizeof(int)*(i-last_zero));
            ans=ans+(long long)solve2(i-last_zero,limit);
            last_zero=i+1;
        }
    }
    memcpy(b,a+last_zero,sizeof(int)*(i-last_zero));
    ans=ans+(long long)solve2(i-last_zero,limit);
    return ans;
}
struct ProductThreshold
{
    long long subarrayCount(int n, int limit, vector <int> Aprefix, int spread, int offset)
    {
        int p=Aprefix.size();
        int i;
        for (i=0;i<p;i++)
        {
            a[i]=Aprefix[i];
        }
        int seed=abs(a[p-1]);
        for (i=p;i<n;i++)
        {
            seed = (seed * 1103515245ull + 12345) % (1ll<<31);
            a[i] = (seed % spread) + offset;
        }
        return solve(n,limit);
    }
};
#ifdef absi2011
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    ProductThreshold aa;
    int n=5;
    int l=8;
    static int aaa[]={3,-1,3,-1,3};
    vector<int> ap;
    for (int i=0;i<sizeof(aaa)/sizeof(int);i++)
    {
        ap.push_back(aaa[i]);
    }
    int s=1;
    int o=1;
    cout<<aa.subarrayCount(n,l,ap,s,o)<<endl;
    return 0;
}
#endif

1000

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<string>
#include<time.h>
#include<math.h>
#include<memory>
#include<vector>
#include<bitset>
#include<fstream>
#include<stdio.h>
#include<utility>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<algorithm>
using namespace std;
struct edge
{
    int y;
    int id;
    edge * next;
};
edge * li[1005];
edge * new_edge()
{
    static edge a[100005];
    static int top=0;
    return &a[top++];
}
void inserts(int x,int y,int z)
{
    edge * t=new_edge();
    t->y=y;
    t->id=z;
    t->next=li[x];
    li[x]=t;
}
void insert_edge(int x,int y,int z)
{
    inserts(x,y,z);
    inserts(y,x,z);
}
int col[10005];
bool vis[10005];
void dfs(int x)
{
    vis[x]=true;
    edge * t;
    for (t=li[x];t!=0;t=t->next)
    {
        if (!vis[t->y])
        {
            col[t->id]=1;
            dfs(t->y);
        }
    }
}
struct ColoringEdgesDiv1
{
    vector <int> findColoring(int n, vector <int> x, vector <int> y)
    {
        srand(time(0));
        int i;
        for (i=0;i<n+n/2;i++)
        {
            insert_edge(x[i],y[i],i);
        }
        for (i=0;i<n;i++)
        {
            if (!vis[i])
            {
                dfs(i);
            }
        }
        vector<int> ans;
        for (i=0;i<n+n/2;i++)
        {
            ans.push_back(col[i]);
        }
        return ans;
    }
};
#ifdef absi2011
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    static int a[]={2, 0, 3, 1, 1, 0, 0, 2, 4};
    vector<int> ap;
    for (int i=0;i<sizeof(a)/sizeof(int);i++)
    {
        ap.push_back(a[i]);
    }
    static int b[]={3, 3, 1, 5, 4, 2, 4, 5, 5};
    vector<int> bp;
    for (int i=0;i<sizeof(b)/sizeof(int);i++)
    {
        bp.push_back(b[i]);
    }
    ColoringEdgesDiv1 aa;
    aa.findColoring(ap.size()/3*2,ap,bp);
    return 0;
}
#endif

　　

 

posted on 2018-07-09 01:13  absi2011  阅读(451)  评论(0)    收藏  举报

博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3 Powered By博客园