KiritoTRw
GitHub
parent
1c7c39b791
commit
53497060fc
|
|
@ -0,0 +1,54 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
char a[100001],c[100001];
|
||||
int ne[100001];
|
||||
int main()
|
||||
{
|
||||
int T,i,j,len,nima[27],mid;
|
||||
char b[27];
|
||||
while(scanf("%d",&T)!=EOF)
|
||||
{
|
||||
getchar();
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s%s",b+1,a+1);
|
||||
for(i=1;i<=26;i++)
|
||||
nima[b[i]-'a']=i-1;
|
||||
len=strlen(a+1);
|
||||
for(i=1;i<=len;i++)
|
||||
c[i]='a'+nima[a[i]-'a'];
|
||||
i=1;j=0;ne[1]=0;
|
||||
while(i<len)
|
||||
{
|
||||
if(j==0||c[i]==c[j])
|
||||
{
|
||||
i++;j++;
|
||||
ne[i]=j;
|
||||
}
|
||||
else
|
||||
j=ne[j];
|
||||
}
|
||||
if(len%2==0)
|
||||
i=len/2+1;
|
||||
else
|
||||
i=len/2+2;
|
||||
j=1;mid=i;
|
||||
while(i<=len)
|
||||
{
|
||||
if(j==0||a[i]==c[j])
|
||||
{
|
||||
i++;j++;
|
||||
}
|
||||
else
|
||||
j=ne[j];
|
||||
}
|
||||
for(i=1;i<=len;i++)
|
||||
printf("%c",a[i]);
|
||||
for(i=j;i<j+len-2*j+2;i++)
|
||||
printf("%c",c[i]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <math.h>
|
||||
#include <cstdlib>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 1050
|
||||
#define mod 100000007
|
||||
int dp[N][N*2][2];
|
||||
int main ()
|
||||
{
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[1][1][0]=1;
|
||||
dp[1][2][1]=1;
|
||||
for(int i=1;i<=1000;++i)
|
||||
{
|
||||
for(int j=1;j<=2*i;++j)
|
||||
{
|
||||
dp[i+1][j][0]=(dp[i+1][j][0]+dp[i][j][0]+2*dp[i][j][1])%mod;
|
||||
dp[i+1][j+1][0]=(dp[i+1][j+1][0]+dp[i][j][1]+dp[i][j][0])%mod;
|
||||
dp[i+1][j][1]=(dp[i+1][j][1]+dp[i][j][1])%mod;
|
||||
dp[i+1][j+1][1]=(dp[i+1][j+1][1]+2*dp[i][j][0]+2*dp[i][j][1])%mod;
|
||||
dp[i+1][j+2][1]=(dp[i+1][j+2][1]+dp[i][j][0]+dp[i][j][1])%mod;
|
||||
}
|
||||
}
|
||||
int n,k;
|
||||
int t;scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&k);
|
||||
printf("%d\n",(dp[n][k][0]+dp[n][k][1])%mod);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
#include <queue>
|
||||
#include <iostream>
|
||||
#define LL __int64
|
||||
using namespace std;
|
||||
struct cmp
|
||||
{
|
||||
bool operator()(LL a, LL b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
};
|
||||
int main()
|
||||
{
|
||||
int t,l,n,f1,f2;
|
||||
LL sum,a,b,x,y;
|
||||
int i,j;
|
||||
scanf("%d", &t);
|
||||
for(j = 0; j < t; j++)
|
||||
{
|
||||
priority_queue<LL> asc;
|
||||
priority_queue<LL, vector<LL>, cmp> desc;
|
||||
scanf("%d%d", &l, &n);
|
||||
y = 0;
|
||||
sum = 0;
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%d", &f2);
|
||||
if(!f2)
|
||||
{
|
||||
scanf("%I64d", &x);
|
||||
if(x > y) desc.push(x);
|
||||
else asc.push(x);
|
||||
}
|
||||
else
|
||||
{
|
||||
a = b = -1;
|
||||
if(!asc.empty()) b = asc.top();
|
||||
if(!desc.empty()) a = desc.top();
|
||||
if(b == y)
|
||||
{
|
||||
asc.pop();
|
||||
continue;
|
||||
}
|
||||
if(a+1 && b+1)
|
||||
{
|
||||
if(a-y > y-b)
|
||||
{
|
||||
sum += y-b;
|
||||
y = b;
|
||||
asc.pop();
|
||||
f1 = 0;
|
||||
}
|
||||
else if(a-y == y-b)
|
||||
{
|
||||
sum += a-y;
|
||||
if(f1) {y = a; desc.pop();}
|
||||
else {y = b; asc.pop();}
|
||||
}
|
||||
else
|
||||
{
|
||||
sum += a-y;
|
||||
y = a;
|
||||
desc.pop();
|
||||
f1 = 1;
|
||||
}
|
||||
}
|
||||
else if(a+1)
|
||||
{
|
||||
sum += a-y;
|
||||
y = a;
|
||||
desc.pop();
|
||||
f1 = 1;
|
||||
}
|
||||
else if(b+1)
|
||||
{
|
||||
sum += y-b;;
|
||||
y = b;
|
||||
asc.pop();
|
||||
f1 = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: %I64d\n", j+1, sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<set>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define pb push_back
|
||||
#define NN 301000
|
||||
typedef pair<int,int> pii;
|
||||
vector<pii> ed[NN];
|
||||
long long ans;
|
||||
int son[NN],fc[NN];
|
||||
int val[NN];
|
||||
void dfs2(int u,int fa,int ecol,int fcnt){
|
||||
ans+=((long long)son[u]-fc[u])*fcnt*val[u];
|
||||
int i,j,sz=ed[u].size(),v,tcol=-1,vv,tfcnt;
|
||||
int totc=0,tott=0;
|
||||
for(i=0,j=0;i<sz;++i){
|
||||
v=ed[u][i].second;
|
||||
if (v==fa) continue;
|
||||
if (tcol!=ed[u][i].first){
|
||||
tcol=ed[u][i].first;
|
||||
totc=0;
|
||||
if (j<sz&&ed[u][j].second==fa) ++j;
|
||||
for(;j<sz&&ed[u][j].first==tcol;++j){
|
||||
vv=ed[u][j].second;
|
||||
if (vv==fa) continue;
|
||||
totc=totc+son[vv]-fc[vv];
|
||||
}
|
||||
tott+=totc;
|
||||
}
|
||||
ans+=((long long)son[u]-tott)*(son[v]-fc[v])*val[u];
|
||||
if (ecol==ed[u][i].first) tfcnt=son[u]-totc;
|
||||
else tfcnt=son[u]-totc+fcnt;
|
||||
dfs2(v,u,ed[u][i].first,tfcnt);
|
||||
}
|
||||
}
|
||||
int dfs1(int u,int fa,int ecol){
|
||||
son[u]=1;
|
||||
fc[u]=0;
|
||||
int i,sz=ed[u].size(),v,tmp;
|
||||
sort(ed[u].begin(),ed[u].end());
|
||||
for(i=0;i<sz;++i){
|
||||
if (ed[u][i].second==fa) continue;
|
||||
v=ed[u][i].second;
|
||||
tmp=dfs1(v,u,ed[u][i].first);
|
||||
son[u]+=tmp;
|
||||
if (ecol==ed[u][i].first) fc[u]+=tmp;
|
||||
}
|
||||
return son[u]-fc[u];
|
||||
}
|
||||
int main(){
|
||||
int n,i,a,b,c;
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
for(i=1;i<=n;++i){
|
||||
scanf("%d",&val[i]);
|
||||
ed[i].clear();
|
||||
}
|
||||
for(i=1;i<n;++i){
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
ed[a].pb(make_pair(c,b));
|
||||
ed[b].pb(make_pair(c,a));
|
||||
}
|
||||
dfs1(1,-1,-1);
|
||||
ans=0;
|
||||
dfs2(1,-1,-1,0);
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
int coef[20],delt[20],inx[20],base[20];
|
||||
int mark[1000010],pri[1000010],priN;
|
||||
__int64 dp[2000][20];
|
||||
void init()
|
||||
{
|
||||
int i,j;
|
||||
for(i=2; i<=1000000; i++) mark[i]=i;
|
||||
for(i=2; i<=1000000; i++)
|
||||
{
|
||||
if(mark[i]==i) pri[priN++]=i;
|
||||
for(j=0; j<priN&&i*pri[j]<=1000000; j++)
|
||||
{
|
||||
mark[i*pri[j]]=pri[j];
|
||||
if(i%pri[j]==0) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
void deal()
|
||||
{
|
||||
__int64 u,ans,num,t,tmpv;
|
||||
int cnt,i,j,k,l,prod,tot,amn,m;
|
||||
scanf("%I64d", &u);
|
||||
for(cnt=0,num=u; num-1;)
|
||||
{
|
||||
if(num>1000000)
|
||||
{
|
||||
t=num;
|
||||
for(j=0; j<priN; j++)
|
||||
{
|
||||
if(num%pri[j]==0)
|
||||
{
|
||||
t=pri[j];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else t=mark[num];
|
||||
inx[cnt]=0;
|
||||
while(num%t==0) num/=t,inx[cnt]++;
|
||||
cnt++;
|
||||
}
|
||||
for(tot=0,prod=1,i=cnt-1; i>=0; i--)
|
||||
{
|
||||
tot+=inx[i],base[i]=prod,prod*=(inx[i]+1);
|
||||
}
|
||||
for(i=0; i<=tot; i++) for(j=0; j<prod; j++) dp[j][i]=0;
|
||||
dp[0][0]=1;
|
||||
for(i=1; i<prod; i++)
|
||||
{
|
||||
for(j=0; j<cnt; j++) delt[j]=i/base[j]%(inx[j]+1);
|
||||
for(j=prod-1; j>=0; j--)
|
||||
{
|
||||
amn=0x3fffffff;
|
||||
for(k=0; k<cnt; k++)
|
||||
{
|
||||
coef[k]=j/base[k]%(inx[k]+1);
|
||||
if(delt[k])
|
||||
{
|
||||
tmpv=(inx[k]-coef[k])/delt[k];
|
||||
if(tmpv<amn) amn=tmpv;
|
||||
}
|
||||
}
|
||||
for(l=1; l<=amn; l++)
|
||||
{
|
||||
for(k=0; k+l<=tot; k++)
|
||||
{
|
||||
tmpv=dp[j][k];
|
||||
for(m=1; m<=l; m++) tmpv*=m+k,tmpv/=m;
|
||||
dp[j+i*l][k+l]+=tmpv;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(ans=dp[prod-1][tot]*dp[prod-1][tot],i=0; i<tot; i++)
|
||||
{
|
||||
ans+=(dp[prod-1][i]+dp[prod-1][i+1])*(dp[prod-1][i]+dp[prod-1][i+1]);
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t--) deal();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <list>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
struct Point
|
||||
{
|
||||
int x,y;
|
||||
Point(int _x = 0,int _y = 0)
|
||||
{
|
||||
x = _x,y = _y;
|
||||
}
|
||||
Point operator - (const Point &b)const
|
||||
{
|
||||
return Point(x-b.x,y-b.y);
|
||||
}
|
||||
int operator ^(const Point &b)const
|
||||
{
|
||||
return x*b.y - y*b.x;
|
||||
}
|
||||
void input()
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
}
|
||||
};
|
||||
struct Line
|
||||
{
|
||||
Point s,e;
|
||||
Line(){}
|
||||
Line(Point _s,Point _e)
|
||||
{
|
||||
s = _s;
|
||||
e = _e;
|
||||
}
|
||||
};
|
||||
bool onSeg(Point P,Line L)
|
||||
{
|
||||
return
|
||||
((L.s-P)^(L.e-P)) == 0 &&
|
||||
(P.x-L.s.x)*(P.x-L.e.x) <= 0 &&
|
||||
(P.y-L.s.y)*(P.y-L.e.y) <= 0;
|
||||
}
|
||||
int sqdis(Point a,Point b)
|
||||
{
|
||||
return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
|
||||
}
|
||||
const int MOD = 10007;
|
||||
int INV[MOD];
|
||||
long long inv(long long a,long long m)
|
||||
{
|
||||
if(a == 1)return 1;
|
||||
return inv(m%a,m)*(m-m/a)%m;
|
||||
}
|
||||
struct Matrix
|
||||
{
|
||||
int mat[330][330];
|
||||
void init()
|
||||
{
|
||||
memset(mat,0,sizeof(mat));
|
||||
}
|
||||
int det(int n)
|
||||
{
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = 0;j < n;j++)
|
||||
mat[i][j] = (mat[i][j]%MOD+MOD)%MOD;
|
||||
int res = 1;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
for(int j = i;j < n;j++)
|
||||
if(mat[j][i]!=0)
|
||||
{
|
||||
for(int k = i;k < n;k++)
|
||||
swap(mat[i][k],mat[j][k]);
|
||||
if(i != j)
|
||||
res = (-res+MOD)%MOD;
|
||||
break;
|
||||
}
|
||||
if(mat[i][i] == 0)
|
||||
{
|
||||
res = -1;
|
||||
break;
|
||||
}
|
||||
for(int j = i+1;j < n;j++)
|
||||
{
|
||||
int mut = (mat[j][i]*inv(mat[i][i],MOD))%MOD;
|
||||
for(int k = i;k < n;k++)
|
||||
mat[j][k] = (mat[j][k]-(mat[i][k]*mut)%MOD+MOD)%MOD;
|
||||
}
|
||||
res = (res * mat[i][i])%MOD;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
Point p[330];
|
||||
int n,R;
|
||||
bool check(int k1,int k2)
|
||||
{
|
||||
if(sqdis(p[k1],p[k2]) > R*R)return false;
|
||||
for(int i = 0;i < n;i++)
|
||||
if(i!=k1 && i!=k2)
|
||||
if(onSeg(p[i],Line(p[k1],p[k2])))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
int g[330][330];
|
||||
int main()
|
||||
{
|
||||
for(int i = 1;i < MOD;i++)
|
||||
INV[i] = inv(i,MOD);
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&n,&R);
|
||||
for(int i = 0;i < n;i++)
|
||||
p[i].input();
|
||||
memset(g,0,sizeof(g));
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = i+1;j <n;j++)
|
||||
if(check(i,j))
|
||||
g[i][j] = g[j][i] = 1;
|
||||
Matrix ret;
|
||||
ret.init();
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = 0;j < n;j++)
|
||||
if(i != j && g[i][j])
|
||||
{
|
||||
ret.mat[i][j] = -1;
|
||||
ret.mat[i][i]++;
|
||||
}
|
||||
printf("%d\n",ret.det(n-1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,343 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAXN = 305;
|
||||
const int MAXM = 100010;
|
||||
struct Edge
|
||||
{
|
||||
int v, next;
|
||||
} shift[MAXN*MAXN*2], edge[MAXN*MAXN*4];
|
||||
int shiftNumber, edgeNumber;
|
||||
int shiftHead[MAXN*MAXN*2], edgeHead[MAXN*MAXN*2];
|
||||
int a[MAXN][MAXN], b[MAXN][MAXN];
|
||||
int al[MAXN*MAXN], bl[MAXN*MAXN];
|
||||
int ta[MAXN], tb[MAXN];
|
||||
int na[MAXM], nb[MAXM];
|
||||
int pa[MAXM][2], pb[MAXM][2];
|
||||
bool va[MAXM], vb[MAXM];
|
||||
int n, nn, ca, cb;
|
||||
int differ[MAXN*MAXN], differNumber;
|
||||
int maxNumber;
|
||||
bool inStack[MAXN*MAXN*2];
|
||||
int dfn[MAXN*MAXN*2], low[MAXN*MAXN*2];
|
||||
int stack[MAXN*MAXN*2], belong[MAXN*MAXN*2];
|
||||
int top, index, componentNumber;
|
||||
inline int min(int x, int y)
|
||||
{
|
||||
return x < y ? x : y;
|
||||
}
|
||||
inline int max(int x, int y)
|
||||
{
|
||||
return x > y ? x : y;
|
||||
}
|
||||
inline void swap(int &x, int &y)
|
||||
{
|
||||
int temp = x;
|
||||
x = y;
|
||||
y = temp;
|
||||
}
|
||||
inline int getPosition(int x, int y)
|
||||
{
|
||||
return x * n + y;
|
||||
}
|
||||
inline int getRow(int pos)
|
||||
{
|
||||
return pos / n;
|
||||
}
|
||||
inline int getColumn(int pos)
|
||||
{
|
||||
return pos % n;
|
||||
}
|
||||
void clearEdges()
|
||||
{
|
||||
shiftNumber = 0;
|
||||
edgeNumber = 0;
|
||||
memset(shiftHead, -1, sizeof(shiftHead));
|
||||
memset(edgeHead, -1, sizeof(edgeHead));
|
||||
}
|
||||
inline void addShift(int u, int v)
|
||||
{
|
||||
shift[shiftNumber].v = v;
|
||||
shift[shiftNumber].next = shiftHead[u];
|
||||
shiftHead[u] = shiftNumber ++;
|
||||
}
|
||||
inline void addEdge(int u, int v)
|
||||
{
|
||||
edge[edgeNumber].v = v;
|
||||
edge[edgeNumber].next = edgeHead[u];
|
||||
edgeHead[u] = edgeNumber ++;
|
||||
}
|
||||
void transpose()
|
||||
{
|
||||
for(int i=0; i<n; ++i)
|
||||
{
|
||||
for(int j=i+1; j<n; ++j)
|
||||
{
|
||||
swap(a[i][j], a[j][i]);
|
||||
swap(b[i][j], b[j][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
void getDifference()
|
||||
{
|
||||
differ[al[0]] = 0;
|
||||
differNumber = 1;
|
||||
for(int i=1; i<nn; ++i)
|
||||
{
|
||||
if(al[i] != al[i-1])
|
||||
{
|
||||
differ[al[i]] = differNumber ++;
|
||||
}
|
||||
}
|
||||
}
|
||||
void getNumberPosition()
|
||||
{
|
||||
memset(na, 0, sizeof(na));
|
||||
memset(nb, 0, sizeof(nb));
|
||||
for(int i=0; i<n; ++i)
|
||||
{
|
||||
for(int j=0; j<n; ++j)
|
||||
{
|
||||
pa[a[i][j]][na[a[i][j]]++] = getPosition(i, j);
|
||||
pb[b[i][j]][nb[b[i][j]]++] = getPosition(i, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
bool isUnreachable()
|
||||
{
|
||||
sort(al, al + nn);
|
||||
sort(bl, bl + nn);
|
||||
for(int i=0; i<nn; ++i)
|
||||
{
|
||||
if(al[i] != bl[i])
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool isReachableByOneStep()
|
||||
{
|
||||
for(int i=0; i<n; ++i)
|
||||
{
|
||||
for(int j=0; j<n; ++j)
|
||||
{
|
||||
ta[j] = a[i][j];
|
||||
tb[j] = b[i][j];
|
||||
}
|
||||
sort(ta, ta + n);
|
||||
sort(tb, tb + n);
|
||||
for(int j=0; j<n; ++j)
|
||||
{
|
||||
if(ta[j] != tb[j])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int myStack[MAXN * MAXN * 8];
|
||||
int myStackTop;
|
||||
void push(int x)
|
||||
{
|
||||
myStack[myStackTop ++] = x;
|
||||
}
|
||||
int pop()
|
||||
{
|
||||
return myStack[-- myStackTop];
|
||||
}
|
||||
bool isEmpty()
|
||||
{
|
||||
return myStackTop == 0;
|
||||
}
|
||||
void dfs(int x, int depth)
|
||||
{
|
||||
int i, t;
|
||||
myStackTop = 0;
|
||||
start:
|
||||
dfn[x] = low[x] = index ++;
|
||||
inStack[x] = true;
|
||||
stack[top++] = x;
|
||||
for(i=edgeHead[x]; i!=-1; i=edge[i].next)
|
||||
{
|
||||
if(dfn[edge[i].v] == -1)
|
||||
{
|
||||
push(x);
|
||||
push(depth);
|
||||
push(i);
|
||||
push(t);
|
||||
x = edge[i].v;
|
||||
depth = depth + 1;
|
||||
goto start;
|
||||
ret:
|
||||
low[x] = min(low[x], low[edge[i].v]);
|
||||
}
|
||||
else if(inStack[edge[i].v])
|
||||
{
|
||||
low[x] = min(low[x] ,dfn[edge[i].v]);
|
||||
}
|
||||
}
|
||||
if(dfn[x] == low[x])
|
||||
{
|
||||
do
|
||||
{
|
||||
t = stack[--top];
|
||||
inStack[t] = false;
|
||||
belong[t] = componentNumber;
|
||||
}
|
||||
while(t != x);
|
||||
++ componentNumber;
|
||||
}
|
||||
if(isEmpty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
t = pop();
|
||||
i = pop();
|
||||
depth = pop();
|
||||
x = pop();
|
||||
goto ret;
|
||||
}
|
||||
void tarjan()
|
||||
{
|
||||
memset(inStack, false, sizeof(inStack));
|
||||
memset(dfn, -1, sizeof(dfn));
|
||||
memset(low, -1, sizeof(low));
|
||||
top = index = componentNumber = 0;
|
||||
for(int i=0; i<differNumber*2; ++i)
|
||||
{
|
||||
if(dfn[i] == -1)
|
||||
{
|
||||
dfs(i, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
bool isReachableByTwoStep()
|
||||
{
|
||||
clearEdges();
|
||||
for(int i=1; i<=maxNumber; ++i)
|
||||
{
|
||||
if(na[i] == 1)
|
||||
{
|
||||
addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][0])), differ[i]<<1);
|
||||
addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][0])), (differ[i]<<1) + 1);
|
||||
}
|
||||
else if(na[i] == 2)
|
||||
{
|
||||
addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][1])), differ[i]<<1);
|
||||
addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][0])), (differ[i]<<1) + 1);
|
||||
addShift(getPosition(getRow(pa[i][1]), getColumn(pb[i][0])), differ[i]<<1);
|
||||
addShift(getPosition(getRow(pa[i][1]), getColumn(pb[i][1])), (differ[i]<<1) + 1);
|
||||
}
|
||||
}
|
||||
for(int i=0; i<n; ++i)
|
||||
{
|
||||
for(int j=0; j<n; ++j)
|
||||
{
|
||||
for(int k=shiftHead[getPosition(i, j)]; k!=-1; k=shift[k].next)
|
||||
{
|
||||
for(int l=shift[k].next; l!=-1; l=shift[l].next)
|
||||
{
|
||||
if((shift[k].v ^ 1) == shift[l].v)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
addEdge(shift[k].v, shift[l].v ^ 1);
|
||||
addEdge(shift[l].v, shift[k].v ^ 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
tarjan();
|
||||
for(int i=0; i<differNumber; ++i)
|
||||
{
|
||||
if(belong[i<<1] == belong[(i<<1)+1])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int caseNumber;
|
||||
scanf("%d", &caseNumber);
|
||||
for(int cas=1; cas<=caseNumber; ++cas)
|
||||
{
|
||||
scanf("%d%d%d", &n, &ca, &cb);
|
||||
nn = n * n;
|
||||
bool isSame = true;
|
||||
maxNumber = 0;
|
||||
for(int i=0,k=0; i<n; ++i)
|
||||
{
|
||||
for(int j=0; j<n; ++j)
|
||||
{
|
||||
scanf("%d", &a[i][j]);
|
||||
al[k++] = a[i][j];
|
||||
maxNumber = max(maxNumber, a[i][j]);
|
||||
}
|
||||
}
|
||||
for(int i=0,k=0; i<n; ++i)
|
||||
{
|
||||
for(int j=0; j<n; ++j)
|
||||
{
|
||||
scanf("%d", &b[i][j]);
|
||||
bl[k++] = b[i][j];
|
||||
if(a[i][j] != b[i][j])
|
||||
{
|
||||
isSame = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case #%d: ", cas);
|
||||
if(isSame)
|
||||
{
|
||||
printf("0\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
if(isUnreachable())
|
||||
{
|
||||
printf("Take off the shoes!\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
int ans = min(ca * 2 + cb, cb * 2 + ca);
|
||||
if(isReachableByOneStep())
|
||||
{
|
||||
ans = ca;
|
||||
}
|
||||
transpose();
|
||||
if(ans > cb)
|
||||
{
|
||||
if(isReachableByOneStep())
|
||||
{
|
||||
ans = cb;
|
||||
}
|
||||
}
|
||||
if(ans > ca + cb)
|
||||
{
|
||||
getDifference();
|
||||
getNumberPosition();
|
||||
if(isReachableByTwoStep())
|
||||
{
|
||||
ans = ca + cb;
|
||||
}
|
||||
else
|
||||
{
|
||||
transpose();
|
||||
getNumberPosition();
|
||||
if(isReachableByTwoStep())
|
||||
{
|
||||
ans = ca + cb;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#define MAXD 1010
|
||||
#define MAXM 2004010
|
||||
#define INF 0x7fffffff
|
||||
int N, first[MAXD], e, v[MAXM], next[MAXM], flow[MAXM];
|
||||
int S, T, d[MAXD], q[MAXD], work[MAXD];
|
||||
long long SUM;
|
||||
void add(int x, int y, int z)
|
||||
{
|
||||
v[e] = y, flow[e] = z;
|
||||
next[e] = first[x], first[x] = e ++;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i, j, x, a;
|
||||
scanf("%d", &N);
|
||||
S = 0, T = N + 1;
|
||||
memset(first, -1, sizeof(first[0]) * (T + 1));
|
||||
SUM = e = 0;
|
||||
for(i = 1; i <= N; i ++)
|
||||
{
|
||||
a = 0;
|
||||
for(j = 1; j <= N; j ++)
|
||||
{
|
||||
scanf("%d", &x), a += x;
|
||||
add(i, j, x), add(j, i, 0);
|
||||
}
|
||||
SUM += a;
|
||||
add(S, i, a), add(i, S, 0);
|
||||
}
|
||||
for(i = 1; i <= N; i ++)
|
||||
{
|
||||
scanf("%d", &x);
|
||||
add(i, T, x), add(T, i, 0);
|
||||
}
|
||||
}
|
||||
int bfs()
|
||||
{
|
||||
int i, j, rear = 0;
|
||||
memset(d, -1, sizeof(d[0]) * (T + 1));
|
||||
d[S] = 0, q[rear ++] = S;
|
||||
for(i = 0; i < rear; i ++)
|
||||
for(j = first[q[i]]; j != -1; j = next[j])
|
||||
if(flow[j] && d[v[j]] == -1)
|
||||
{
|
||||
d[v[j]] = d[q[i]] + 1, q[rear ++] = v[j];
|
||||
if(v[j] == T) return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int dfs(int cur, int a)
|
||||
{
|
||||
if(cur == T)
|
||||
return a;
|
||||
for(int &i = work[cur]; i != -1; i = next[i])
|
||||
if(flow[i] && d[v[i]] == d[cur] + 1)
|
||||
if(int t = dfs(v[i], std::min(a, flow[i])))
|
||||
{
|
||||
flow[i] -= t, flow[i ^ 1] += t;
|
||||
return t;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
long long dinic()
|
||||
{
|
||||
long long ans = 0;
|
||||
while(bfs())
|
||||
{
|
||||
memcpy(work, first, sizeof(first[0]) * (T + 1));
|
||||
while(int t = dfs(S, INF))
|
||||
ans += t;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
printf("%lld\n", SUM - dinic());
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t --)
|
||||
{
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct Node
|
||||
{
|
||||
int dps;
|
||||
int hp;
|
||||
}a[30];
|
||||
int cmp(Node x,Node y)
|
||||
{
|
||||
return x.hp*y.dps<y.hp*x.dps;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i;
|
||||
int sum,ans;
|
||||
while(~scanf("%d",&t))
|
||||
{
|
||||
sum = ans = 0;
|
||||
for(i = 0;i<t;i++)
|
||||
{
|
||||
scanf("%d%d",&a[i].dps,&a[i].hp);
|
||||
sum+=a[i].dps;
|
||||
}
|
||||
sort(a,a+t,cmp);
|
||||
for(i = 0;i<t;i++)
|
||||
{
|
||||
ans+=sum*a[i].hp;
|
||||
sum-=a[i].dps;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#define MAXN 100010
|
||||
using namespace std;
|
||||
struct point{long long x,y;}a[MAXN];
|
||||
bool cmp(point A,point B)
|
||||
{
|
||||
if(A.x<B.x) return true;
|
||||
if(A.x==B.x&&A.y<B.y) return true;
|
||||
return false;
|
||||
}
|
||||
long long ABS(long long A)
|
||||
{
|
||||
if(A<0) A=-A;
|
||||
return A;
|
||||
}
|
||||
long long work(int k,int n)
|
||||
{
|
||||
int i;
|
||||
long long ans=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
ans+=ABS(a[k].x-a[i].x);
|
||||
ans+=ABS(a[k].y-a[i].y);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int test,n,s,e,i;
|
||||
long long ans,t;
|
||||
scanf("%d",&test);
|
||||
while(test--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%I64d%I64d",&a[i].x,&a[i].y);
|
||||
}
|
||||
sort(a,a+n,cmp);
|
||||
s=n/2-250;e=n/2+250;
|
||||
if(s<0) s=0;
|
||||
if(e>n-1) e=n-1;
|
||||
ans=1;ans<<=60;
|
||||
for(i=s;i<=e;i++)
|
||||
{
|
||||
t=work(i,n);
|
||||
if(ans>t) ans=t;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long int Int64;
|
||||
int N;
|
||||
struct Point
|
||||
{
|
||||
Int64 x, y, sum;
|
||||
}e[100005];
|
||||
bool cmpx(Point a, Point b)
|
||||
{
|
||||
return a.x < b.x;
|
||||
}
|
||||
bool cmpy(Point a, Point b)
|
||||
{
|
||||
return a.y < b.y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, t;
|
||||
Int64 sum, Min;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
Min = 1LL << 62;
|
||||
scanf("%d", &N);
|
||||
for (int i = 1; i <= N; ++i) {
|
||||
scanf("%I64d %I64d", &e[i].x, &e[i].y);
|
||||
t = e[i].x, e[i].x += e[i].y;
|
||||
e[i].y -= t, e[i].sum = 0;
|
||||
}
|
||||
sort(e+1, e+1+N, cmpx);
|
||||
sum = 0;
|
||||
for (int i = 1; i <= N; ++i) {
|
||||
e[i].sum += (i-1) * e[i].x - sum;
|
||||
sum += e[i].x;
|
||||
}
|
||||
sum = 0;
|
||||
for (int i = N; i >= 1; --i) {
|
||||
e[i].sum += sum - (N-i) * e[i].x;
|
||||
sum += e[i].x;
|
||||
}
|
||||
sort(e+1, e+1+N, cmpy);
|
||||
sum = 0;
|
||||
for (int i = 1; i <= N; ++i) {
|
||||
e[i].sum += (i-1) * e[i].y - sum;
|
||||
sum += e[i].y;
|
||||
}
|
||||
sum = 0;
|
||||
for (int i = N; i >= 1; --i) {
|
||||
e[i].sum += sum - (N-i) * e[i].y;
|
||||
Min = min(Min, e[i].sum);
|
||||
sum += e[i].y;
|
||||
}
|
||||
printf("%I64d\n", Min >> 1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int maxn = 100010;
|
||||
int t, n, k;
|
||||
int mach[maxn], father[maxn];
|
||||
struct Edge {
|
||||
int u, v, c;
|
||||
}edge;
|
||||
vector<Edge> vv;
|
||||
bool cmp(Edge a, Edge b)
|
||||
{
|
||||
return a.c > b.c;
|
||||
}
|
||||
void initSet()
|
||||
{
|
||||
for (int i = 0; i < maxn; ++i) {
|
||||
father[i] = i;
|
||||
mach[i] = 0;
|
||||
}
|
||||
}
|
||||
int find(int x)
|
||||
{
|
||||
if (x != father[x]) {
|
||||
father[x] = find(father[x]);
|
||||
}
|
||||
return father[x];
|
||||
}
|
||||
void merge(int a, int b)
|
||||
{
|
||||
a = find(a);
|
||||
b = find(b);
|
||||
if (a == b) return ;
|
||||
if (a < b) {
|
||||
father[b] = a;
|
||||
mach[a] += mach[b];
|
||||
} else {
|
||||
father[a] = b;
|
||||
mach[b] += mach[a];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &t);
|
||||
while (t--) {
|
||||
scanf("%d%d", &n, &k);
|
||||
vv.clear();
|
||||
initSet();
|
||||
int u, v, c;
|
||||
__int64 ans = 0;
|
||||
for (int i = 0; i < n - 1; ++i) {
|
||||
scanf("%d%d%d", &u, &v, &c);
|
||||
edge.u = u; edge.v = v; edge.c = c;
|
||||
vv.push_back(edge);
|
||||
ans += c;
|
||||
}
|
||||
for (int i = 0; i < k; ++i) {
|
||||
scanf("%d", &u);
|
||||
mach[u] = 1;
|
||||
}
|
||||
sort(vv.begin(), vv.end(), cmp);
|
||||
for (int i = 0; i < n - 1; ++i) {
|
||||
u = find(vv[i].u);
|
||||
v = find(vv[i].v);
|
||||
if (mach[u] + mach[v] <= 1) {
|
||||
merge(u, v);
|
||||
ans -= vv[i].c;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
const int N=3000;
|
||||
const int inf=1e9;
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int a,b;
|
||||
void read(){ scanf("%d%d",&a,&b); }
|
||||
bool operator <(const node tmp)const { return a+b<tmp.a+tmp.b; }
|
||||
}no[N];
|
||||
int opt[N][N],n,h;
|
||||
int solve()
|
||||
{
|
||||
int sum=0;
|
||||
for(int i=1;i<=n;i++) sum+=no[i].a;
|
||||
for(int j=1;j<=n;j++) opt[0][j]=inf;
|
||||
opt[0][0]=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
opt[i][0]=0;
|
||||
for(int j=1;j<=n;j++){
|
||||
opt[i][j]=opt[i-1][j];
|
||||
if(sum-opt[i-1][j-1]+no[i].b>=h)
|
||||
opt[i][j]=min(opt[i][j],opt[i-1][j-1]+no[i].a);
|
||||
}
|
||||
}
|
||||
for(int j=n;j>=0;j--)
|
||||
if(opt[n][j]!=inf)
|
||||
return j;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n)!=-1)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
no[i].read();
|
||||
scanf("%d",&h);
|
||||
sort(no+1,no+n+1);
|
||||
cout<<solve()<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include<stdio.h>
|
||||
#define N 1001
|
||||
int n,k,a[N],i,tmp,sg;
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&k)!=-1)
|
||||
{
|
||||
a[0]=-1;
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
if(k==1)
|
||||
{
|
||||
puts("Alice");
|
||||
continue;
|
||||
}
|
||||
sg=0;
|
||||
for(i=n;i>0;i-=2)
|
||||
sg^=(tmp=a[i]-a[i-1]-1);
|
||||
if(n%2==1&&k==2)
|
||||
sg=sg^(tmp-1)^tmp;
|
||||
if(sg==0)
|
||||
puts("Bob");
|
||||
else
|
||||
puts("Alice");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,216 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAXN = 1001;
|
||||
const double eps = 1e-12;
|
||||
int dblcmp(double x)
|
||||
{
|
||||
if(fabs(x) < eps)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return x > 0 ? 1 : -1;
|
||||
}
|
||||
struct Point
|
||||
{
|
||||
double x, y, z;
|
||||
inline void input2d()
|
||||
{
|
||||
scanf("%lf%lf",&x,&y);
|
||||
z = 100.0;
|
||||
}
|
||||
inline void input3d()
|
||||
{
|
||||
scanf("%lf%lf%lf",&x,&y,&z);
|
||||
}
|
||||
bool operator < (const Point &point) const
|
||||
{
|
||||
if(y == point.y)
|
||||
{
|
||||
return x < point.x;
|
||||
}
|
||||
return y < point.y;
|
||||
}
|
||||
}machine[MAXN], light[3], shadow[3][MAXN], final[MAXN * 3];
|
||||
int n, shadowNumber[3], shadowPoly[3][MAXN], shadowPolyTop[3], finalNumber;
|
||||
double operator * (const Point &x, const Point &y)
|
||||
{
|
||||
return x.x * y.y - x.y * y.x;
|
||||
}
|
||||
Point operator - (const Point &x, const Point &y)
|
||||
{
|
||||
Point r;
|
||||
r.x = x.x - y.x;
|
||||
r.y = x.y - y.y;
|
||||
return r;
|
||||
}
|
||||
bool operator == (const Point &a, const Point &b)
|
||||
{
|
||||
return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
|
||||
}
|
||||
struct Line
|
||||
{
|
||||
Point a, b;
|
||||
double ang;
|
||||
}line[MAXN*3], stack[MAXN*3];
|
||||
int lineNumber, stackTop;
|
||||
bool operator < (const Line &x, const Line &y)
|
||||
{
|
||||
if(fabs(x.ang - y.ang) < eps)
|
||||
{
|
||||
return (y.b - x.a) * (x.b - y.a) > eps;
|
||||
}
|
||||
return x.ang < y.ang;
|
||||
}
|
||||
Point operator * (const Line &x, const Line &y)
|
||||
{
|
||||
double a1 = (y.b - x.a) * (y.a - x.a);
|
||||
double a2 = (y.a - x.b) * (y.b - x.b);
|
||||
Point r;
|
||||
r.x = (x.a.x * a2 + x.b.x * a1) / (a1 + a2);
|
||||
r.y = (x.a.y * a2 + x.b.y * a1) / (a1 + a2);
|
||||
return r;
|
||||
}
|
||||
bool mult(const Point &s, const Point &e, const Point &o)
|
||||
{
|
||||
return (s.x - o.x) * (e.y - o.y) >= (e.x - o.x) * (s.y - o.y);
|
||||
}
|
||||
void graham(Point p[], int n, int res[], int &top)
|
||||
{
|
||||
int len;
|
||||
top = 1;
|
||||
sort(p, p + n);
|
||||
if(n == 0) return;
|
||||
res[0] = 0;
|
||||
if(n == 1) return;
|
||||
res[1] = 1;
|
||||
if(n == 2) return;
|
||||
res[2] = 2;
|
||||
for(int i=2;i<n;++i)
|
||||
{
|
||||
while(top && mult(p[i], p[res[top]], p[res[top-1]]))
|
||||
{
|
||||
-- top;
|
||||
}
|
||||
res[++top] = i;
|
||||
}
|
||||
len = top;
|
||||
res[++top] = n - 2;
|
||||
for(int i=n-3;i>=0;--i)
|
||||
{
|
||||
while(top!=len && mult(p[i], p[res[top]], p[res[top-1]]))
|
||||
{
|
||||
-- top;
|
||||
}
|
||||
res[++top] = i;
|
||||
}
|
||||
}
|
||||
double cross(Point &a, Point &b, Point &o)
|
||||
{
|
||||
return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
|
||||
}
|
||||
bool judgeOut(const Line &x, const Point &p)
|
||||
{
|
||||
return (p - x.a) * (x.b - x.a) > eps;
|
||||
}
|
||||
bool isParellel(const Line &x, const Line &y)
|
||||
{
|
||||
return fabs((x.b - x.a) * (y.b - y.a)) < eps;
|
||||
}
|
||||
double getArea(Point p[], int n)
|
||||
{
|
||||
double ans = 0.0;
|
||||
for(int i=2;i<n;++i)
|
||||
{
|
||||
ans += fabs(cross(p[i], p[i-1], p[0]));
|
||||
}
|
||||
return ans * 0.5;
|
||||
}
|
||||
void halfPlane()
|
||||
{
|
||||
finalNumber = 0;
|
||||
sort(line, line + lineNumber);
|
||||
stackTop = 1;
|
||||
int bottom = 0, tmp = 1;
|
||||
for(int i=1;i<lineNumber;++i)
|
||||
{
|
||||
if(line[i].ang - line[i-1].ang > eps)
|
||||
{
|
||||
line[tmp++] = line[i];
|
||||
}
|
||||
}
|
||||
lineNumber = tmp;
|
||||
stack[0] = line[0], stack[1] = line[1];
|
||||
for(int i=2;i<lineNumber;++i)
|
||||
{
|
||||
if(isParellel(stack[stackTop], stack[stackTop-1]) || isParellel(stack[bottom], stack[bottom+1]))
|
||||
{
|
||||
return;
|
||||
}
|
||||
while(bottom < stackTop && judgeOut(line[i], stack[stackTop] * stack[stackTop - 1]))
|
||||
{
|
||||
-- stackTop;
|
||||
}
|
||||
while(bottom < stackTop && judgeOut(line[i], stack[bottom] * stack[bottom + 1]))
|
||||
{
|
||||
++ bottom;
|
||||
}
|
||||
stack[++stackTop] = line[i];
|
||||
}
|
||||
while(bottom < stackTop && judgeOut(stack[bottom], stack[stackTop] * stack[stackTop - 1]))
|
||||
{
|
||||
-- stackTop;
|
||||
}
|
||||
while(bottom < stackTop && judgeOut(stack[stackTop], stack[bottom] * stack[bottom + 1]))
|
||||
{
|
||||
++ bottom;
|
||||
}
|
||||
if(stackTop <= bottom + 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
stack[++stackTop] = stack[bottom];
|
||||
for(int i=bottom;i<stackTop;++i)
|
||||
{
|
||||
final[finalNumber ++] = stack[i] * stack[i+1];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d", &n))
|
||||
{
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
machine[i].input3d();
|
||||
}
|
||||
for(int i=0;i<3;++i)
|
||||
{
|
||||
light[i].input2d();
|
||||
}
|
||||
lineNumber = 0;
|
||||
for(int i=0;i<3;++i)
|
||||
{
|
||||
shadowNumber[i] = 0;
|
||||
for(int j=0;j<n;++j)
|
||||
{
|
||||
shadow[i][j].x = 100.0 * (light[i].x - machine[j].x) / (machine[j].z - 100.0) + light[i].x;
|
||||
shadow[i][j].y = 100.0 * (light[i].y - machine[j].y) / (machine[j].z - 100.0) + light[i].y;
|
||||
}
|
||||
graham(shadow[i], n, shadowPoly[i], shadowPolyTop[i]);
|
||||
shadowPoly[i][shadowPolyTop[i]] = shadowPoly[i][0];
|
||||
for(int j=0;j<shadowPolyTop[i];++j)
|
||||
{
|
||||
line[lineNumber].a = shadow[i][shadowPoly[i][j]];
|
||||
line[lineNumber].b = shadow[i][shadowPoly[i][j+1]];
|
||||
line[lineNumber].ang = atan2(line[lineNumber].b.y - line[lineNumber].a.y,
|
||||
line[lineNumber].b.x - line[lineNumber].a.x);
|
||||
++ lineNumber;
|
||||
}
|
||||
}
|
||||
halfPlane();
|
||||
printf("%.2lf\n", getArea(final, finalNumber));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int M=1<<11;
|
||||
const int MAX=0x1f1f1f1f;
|
||||
int s[25],dp[25][M];
|
||||
int t[M];
|
||||
int a[11];
|
||||
int main()
|
||||
{
|
||||
int N,i,j,k,len,tmp,r;
|
||||
for(i=0;i<M;i++)
|
||||
{
|
||||
tmp=0;
|
||||
j=i;
|
||||
while(j!=0)
|
||||
{
|
||||
tmp+=(j&1);
|
||||
j=j>>1;
|
||||
}
|
||||
t[i]=tmp;
|
||||
}
|
||||
while(scanf("%d",&N)!=EOF)
|
||||
{
|
||||
memset(s,0,sizeof(s));;
|
||||
for(i=0;i<N;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
}
|
||||
if(N<2)
|
||||
{
|
||||
printf("impossible\n");
|
||||
continue;
|
||||
}
|
||||
for(i=1;i<=22;i++)
|
||||
{
|
||||
for(j=0;j<N;j++)
|
||||
{
|
||||
if(a[j]&(1<<(i-1)))
|
||||
{
|
||||
s[i]|=(1<<j);
|
||||
}
|
||||
}
|
||||
if(s[i]!=0)
|
||||
len=i+1;
|
||||
}
|
||||
memset(dp,MAX,sizeof(dp));
|
||||
dp[0][0]=0;
|
||||
for(r=1;r<=len;r++)
|
||||
{
|
||||
for(j=0;j<(1<<N);j++)
|
||||
{
|
||||
if(dp[r-1][j]<MAX)
|
||||
{
|
||||
tmp=j&s[r];
|
||||
for(k=tmp;k<(1<<N);k++)
|
||||
{
|
||||
if((k&tmp)==tmp&&
|
||||
((s[r]^j)&(k^tmp))==(k^tmp)&&
|
||||
((t[(s[r]^j)^(k^tmp)]&1)==0||t[(s[r]^j)^(k^tmp)]<N))
|
||||
{
|
||||
dp[r][k]=min(dp[r][k],dp[r-1][j]+(t[k^tmp]+(t[(s[r]^j)^(k^tmp)]&1))*(1<<(r-1)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int Min=MAX;
|
||||
for(j=0;j<(1<<N);j++)
|
||||
{
|
||||
if((s[j]&1)==0)
|
||||
Min=min(Min,dp[len][j]);
|
||||
}
|
||||
printf("%d\n",Min);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
struct p
|
||||
{
|
||||
int a[50][2];
|
||||
}p[50010];
|
||||
double b[51000];
|
||||
queue<int> q;
|
||||
int s,t,n;
|
||||
double m;
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
memset(p,-1,sizeof(p));
|
||||
for(int i=0;i<51000;i++)
|
||||
b[i]=-1;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
int x;
|
||||
scanf("%d",&x);
|
||||
for(int j=0;j<x;j++)
|
||||
{
|
||||
scanf("%d",&p[i].a[j][0]);
|
||||
scanf("%d",&p[i].a[j][1]);
|
||||
}
|
||||
}
|
||||
scanf("%d%d%lf",&s,&t,&m);
|
||||
b[s]=0;
|
||||
q.push(s);
|
||||
int hd;
|
||||
while(!q.empty())
|
||||
{
|
||||
hd=q.front();
|
||||
q.pop();
|
||||
for(int i=0;i<50;i++)
|
||||
{
|
||||
if(p[hd].a[i][0]==hd)
|
||||
continue;
|
||||
if(p[hd].a[i][0]!=-1&&(b[p[hd].a[i][0]]+1<1e-8||b[p[hd].a[i][0]]>b[hd]+(100.0-b[hd])*p[hd].a[i][1]/100))
|
||||
{
|
||||
q.push(p[hd].a[i][0]);
|
||||
b[p[hd].a[i][0]]=b[hd]+(100.0-b[hd])*p[hd].a[i][1]/100;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(b[t]+1<1e-8)
|
||||
cout<<"IMPOSSIBLE!\n";
|
||||
else
|
||||
printf("%.2lf\n",m*b[t]/100);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,183 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
const int MAXN = 100010;
|
||||
struct Point
|
||||
{
|
||||
__int64 x, y;
|
||||
}point[MAXN], high[2][MAXN], low[2][MAXN], merge[MAXN * 2];
|
||||
int pointNumber, highNumber[2], lowNumber[2], mergeNumber;
|
||||
int n, stack[MAXN], top;
|
||||
__int64 a[MAXN];
|
||||
Point operator + (const Point &a, const Point &b)
|
||||
{
|
||||
Point r;
|
||||
r.x = a.x + b.x;
|
||||
r.y = a.y + b.y;
|
||||
return r;
|
||||
}
|
||||
Point operator - (const Point &a, const Point &b)
|
||||
{
|
||||
Point r;
|
||||
r.x = a.x - b.x;
|
||||
r.y = a.y - b.y;
|
||||
return r;
|
||||
}
|
||||
inline __int64 operator * (const Point &a, const Point &b)
|
||||
{
|
||||
return a.x * b.y - a.y * b.x;
|
||||
}
|
||||
inline __int64 absolute(int x)
|
||||
{
|
||||
return x >= 0 ? x : -x;
|
||||
}
|
||||
inline double max(const double &x, const double &y)
|
||||
{
|
||||
return x > y ? x : y;
|
||||
}
|
||||
inline __int64 cross(const Point &a, const Point &b, const Point &o)
|
||||
{
|
||||
return (a - o) * (b - o);
|
||||
}
|
||||
void getBound(Point result[], int &resultNumber, bool isHigh)
|
||||
{
|
||||
if(pointNumber == 1)
|
||||
{
|
||||
result[0] = point[0];
|
||||
resultNumber = 1;
|
||||
return;
|
||||
}
|
||||
stack[0] = 0;
|
||||
stack[1] = 1;
|
||||
top = 2;
|
||||
if(isHigh)
|
||||
{
|
||||
for(int i=2;i<pointNumber;++i)
|
||||
{
|
||||
while(top >= 2 && cross(point[stack[top-2]], point[i], point[stack[top-1]]) < 0)
|
||||
{
|
||||
-- top;
|
||||
}
|
||||
stack[top++] = i;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int i=2;i<pointNumber;++i)
|
||||
{
|
||||
while(top >= 2 && cross(point[stack[top-2]], point[i], point[stack[top-1]]) > 0)
|
||||
{
|
||||
-- top;
|
||||
}
|
||||
stack[top++] = i;
|
||||
}
|
||||
}
|
||||
resultNumber = top;
|
||||
for(int i=0;i<top;++i)
|
||||
{
|
||||
result[i].x = point[stack[i]].x;
|
||||
result[i].y = point[stack[i]].y;
|
||||
}
|
||||
}
|
||||
void mergeBound(Point p1[], int len1, Point p2[], int len2, bool isHigh)
|
||||
{
|
||||
merge[mergeNumber++] = p1[0] + p2[0];
|
||||
int pNum1 = 1, pNum2 = 1;
|
||||
while(pNum1 < len1 || pNum2 < len2)
|
||||
{
|
||||
if(pNum1 == len1)
|
||||
{
|
||||
merge[mergeNumber++] = p1[pNum1 - 1] + p2[pNum2 ++];
|
||||
}
|
||||
else if(pNum2 == len2)
|
||||
{
|
||||
merge[mergeNumber++] = p1[pNum1 ++] + p2[pNum2 - 1];
|
||||
}
|
||||
else
|
||||
{
|
||||
Point temp0 = p1[pNum1 - 1] + p2[pNum2 - 1];
|
||||
Point temp1 = p1[pNum1] + p2[pNum2 - 1];
|
||||
Point temp2 = p1[pNum1 - 1] + p2[pNum2];
|
||||
if(isHigh)
|
||||
{
|
||||
if(cross(temp1, temp2, temp0) < 0)
|
||||
{
|
||||
merge[mergeNumber++] = temp1;
|
||||
++ pNum1;
|
||||
}
|
||||
else
|
||||
{
|
||||
merge[mergeNumber++] = temp2;
|
||||
++ pNum2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(cross(temp1, temp2, temp0) > 0)
|
||||
{
|
||||
merge[mergeNumber++] = temp1;
|
||||
++ pNum1;
|
||||
}
|
||||
else
|
||||
{
|
||||
merge[mergeNumber++] = temp2;
|
||||
++ pNum2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
double solve(int l, int r)
|
||||
{
|
||||
if(l == r)
|
||||
{
|
||||
return absolute(a[l]);
|
||||
}
|
||||
int mid = (l + r) >> 1;
|
||||
double ansL = solve(l, mid);
|
||||
double ansR = solve(mid + 1, r);
|
||||
double ans = max(ansL, ansR);
|
||||
__int64 sum = 0;
|
||||
pointNumber = 0;
|
||||
for(int i=mid;i>=l;--i)
|
||||
{
|
||||
sum += a[i];
|
||||
point[pointNumber].x = mid - i + 1;
|
||||
point[pointNumber].y = sum;
|
||||
++ pointNumber;
|
||||
}
|
||||
getBound(high[0], highNumber[0], true);
|
||||
getBound(low[0], lowNumber[0], false);
|
||||
sum = 0;
|
||||
pointNumber = 0;
|
||||
for(int i=mid+1;i<=r;++i)
|
||||
{
|
||||
sum += a[i];
|
||||
point[pointNumber].x = i - mid;
|
||||
point[pointNumber].y = sum;
|
||||
++ pointNumber;
|
||||
}
|
||||
getBound(high[1], highNumber[1], true);
|
||||
getBound(low[1], lowNumber[1], false);
|
||||
mergeNumber = 0;
|
||||
mergeBound(high[0], highNumber[0], high[1], highNumber[1], true);
|
||||
mergeBound(low[0], lowNumber[0], low[1], lowNumber[1], false);
|
||||
for(int i=0;i<mergeNumber;++i)
|
||||
{
|
||||
ans = max(ans, fabs((double)merge[i].y) / sqrt((double)merge[i].x));
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d", &n))
|
||||
{
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
scanf("%I64d", &a[i]);
|
||||
}
|
||||
double ans = solve(0, n - 1);
|
||||
printf("%.6lf\n", ans * ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
typedef long long int Int64;
|
||||
int p[1000005], rec[100005], cnt;
|
||||
void getprime()
|
||||
{
|
||||
int k;
|
||||
for (int i = 4; i <= 1000000; i += 2) {
|
||||
p[i] = 1;
|
||||
}
|
||||
for (int i = 3; i <= 1000; i += 2) {
|
||||
k = 2 * i;
|
||||
for (int j = i * i; j <= 1000000; j += k) {
|
||||
p[j] = 1;
|
||||
}
|
||||
}
|
||||
rec[1] = 2;
|
||||
cnt = 1;
|
||||
for (int i = 3; i <= 1000000; i += 2) {
|
||||
if (!p[i]) {
|
||||
rec[++cnt] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, LIM, flag, ca = 0;
|
||||
Int64 a, b;
|
||||
getprime();
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
flag = 0;
|
||||
scanf("%I64d %I64d", &a, &b);
|
||||
LIM = (int)sqrt(double(a));
|
||||
for (int i = 1; rec[i] <= LIM; ++i) {
|
||||
if (a % rec[i] == 0) {
|
||||
if (b % rec[i] != 0) {
|
||||
flag = 1;
|
||||
break;
|
||||
}
|
||||
while (a % rec[i] == 0) {
|
||||
a /= rec[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (a != 1 && b % a != 0) {
|
||||
flag = 1;
|
||||
}
|
||||
printf("Case #%d: ", ++ca);
|
||||
printf(flag ? "NO\n" : "YES\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
void Solve(LL a,LL b,LL n)
|
||||
{
|
||||
LL cnt=0;
|
||||
LL max=b+a*n;
|
||||
for(LL i=0;i<64;i++)
|
||||
{
|
||||
LL m=(LL)1<<i;
|
||||
LL mm=m;
|
||||
if(m>max) break;
|
||||
m<<=1;
|
||||
LL cur=a+b;
|
||||
LL j=0;
|
||||
while(j<m&&j<n)
|
||||
{
|
||||
LL upper=cur+(mm-(cur%mm))-(LL)1;
|
||||
LL step=(upper-cur)/a+(LL)1;
|
||||
if(j+step>=n) step=n-j;
|
||||
if(j+step>=m) step=m-j;
|
||||
if(cur&(LL)1<<i)
|
||||
{
|
||||
cnt+=step*(n/m);
|
||||
if(j+step<(n%m)) cnt+=step;
|
||||
else if(j<(n%m)) cnt+=(n%m)-j;
|
||||
}
|
||||
cur+=a*step;
|
||||
j+=step;
|
||||
}
|
||||
}
|
||||
cout<<cnt<<endl;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,k=1;
|
||||
LL a,b,n,i,j;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
cin>>a>>b>>n;
|
||||
cout<<"Case #"<<k++<<": ";
|
||||
Solve(a,b,n);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#include<math.h>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int dp[40][40];
|
||||
char s1[100], s2[100], st[10010][30];
|
||||
const int inf = 0x7f7f7f7f;
|
||||
struct node
|
||||
{
|
||||
char word[30];
|
||||
node *next[30];
|
||||
}root;
|
||||
node p[100000];
|
||||
int num, flag, vnum, fuck;
|
||||
map<string,int>mp;
|
||||
int f[100000];
|
||||
void init( )
|
||||
{
|
||||
for( int i = 0; i < 40; i++)
|
||||
for( int j = 0; j < 40; j++)
|
||||
dp[i][j] = inf;
|
||||
}
|
||||
int diff( char *s1, char *s2)
|
||||
{
|
||||
init();
|
||||
int x = strlen(s1+1);
|
||||
int y = strlen(s2+1);
|
||||
for( int i = 0; i <= x; i++)
|
||||
dp[i][0] = i;
|
||||
for( int j = 0; j <= y; j++)
|
||||
dp[0][j] = j;
|
||||
for( int i = 1; i <= x; i++)
|
||||
{
|
||||
for( int j = 1; j <= y; j++)
|
||||
{
|
||||
dp[i][j] = min(min(dp[i-1][j]+1, dp[i][j-1]+1), dp[i-1][j-1]+ !(s1[i]==s2[j]) );
|
||||
}
|
||||
}
|
||||
return dp[x][y];
|
||||
}
|
||||
void insert(node *q, char *str)
|
||||
{
|
||||
node *l = q;
|
||||
while( l )
|
||||
{
|
||||
int dis = diff( l->word, str);
|
||||
if( ! l->next[dis] )
|
||||
{
|
||||
l->next[dis] = &p[num++];
|
||||
strcpy(l->next[dis]->word + 1, str + 1);
|
||||
break;
|
||||
}
|
||||
l = l->next[dis];
|
||||
}
|
||||
}
|
||||
void sfind(node *q, char *str, int d)
|
||||
{
|
||||
if( flag )
|
||||
return ;
|
||||
node *l = q;
|
||||
if( l == NULL )
|
||||
return;
|
||||
int dis = diff(str, l->word);
|
||||
if( dis <= d )
|
||||
{
|
||||
fuck++;
|
||||
}
|
||||
for( int x = dis-d; x <= dis+d; x++)
|
||||
{
|
||||
if( x >= 0 && x <= 20 && l->next[x] )
|
||||
sfind(l->next[x], str, d);
|
||||
}
|
||||
}
|
||||
int main( )
|
||||
{
|
||||
int N, M, d, cnt, T, abc = 1;
|
||||
char str[1000];
|
||||
scanf("%d",&T);
|
||||
while( T-- )
|
||||
{
|
||||
scanf("%d%d",&N,&M);
|
||||
memset(p,0,sizeof(p));
|
||||
for( int i = 0; i < 30; i++)
|
||||
root.next[i] = NULL;
|
||||
num = 0;
|
||||
int cnum = 1;
|
||||
strcpy(st[0] + 1, root.word+1);
|
||||
for( int i = 1; i <= N; i++)
|
||||
{
|
||||
scanf("%s",st[i]+1);
|
||||
insert(&root, st[i]);
|
||||
}
|
||||
d = 1;
|
||||
printf("Case #%d:\n", abc++);
|
||||
for( int i = 1; i <= M; i++)
|
||||
{
|
||||
vnum = 0;
|
||||
flag = 0;
|
||||
fuck = 0;
|
||||
scanf("%s%d",str+1, &d);
|
||||
sfind(&root, str, d);
|
||||
printf("%d\n", fuck);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=2010;
|
||||
int n,indeg[N];
|
||||
char str[N][N];
|
||||
int main(){
|
||||
int t,cases=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
int flag=0;
|
||||
memset(indeg,0,sizeof(indeg));
|
||||
int i,j;
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%s",str[i]);
|
||||
for(j=0;j<n;j++)
|
||||
if(str[i][j]=='1')
|
||||
indeg[j]++;
|
||||
}
|
||||
for(i=0;i<n;i++){
|
||||
for(j=0;j<n;j++)
|
||||
if(indeg[j]==0)
|
||||
break;
|
||||
if(j==n){
|
||||
flag=1;
|
||||
break;
|
||||
}else{
|
||||
indeg[j]--;
|
||||
for(int k=0;k<n;k++)
|
||||
if(str[j][k]=='1')
|
||||
indeg[k]--;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
printf("Case #%d: Yes\n",++cases);
|
||||
else
|
||||
printf("Case #%d: No\n",++cases);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define lson u<<1
|
||||
#define rson u<<1|1
|
||||
const int maxn=100010;
|
||||
int st[maxn],ed[maxn];
|
||||
int q[maxn],dat[maxn<<1];
|
||||
struct Node{
|
||||
int lef,rig,delta;
|
||||
}T[maxn<<2];
|
||||
void Build(int u,int l,int r){
|
||||
T[u].lef=l;
|
||||
T[u].rig=r;
|
||||
T[u].delta=0;
|
||||
if(l==r)return;
|
||||
int mid=(l+r)>>1;
|
||||
Build(lson,l,mid);
|
||||
Build(rson,mid+1,r);
|
||||
}
|
||||
void PushDown(int u){
|
||||
if(T[u].delta>0){
|
||||
T[lson].delta+=T[u].delta;
|
||||
T[rson].delta+=T[u].delta;
|
||||
T[u].delta=0;
|
||||
}
|
||||
}
|
||||
void Update(int u,int l,int r){
|
||||
if(l<=T[u].lef&&T[u].rig<=r){T[u].delta++;return;}
|
||||
else {
|
||||
PushDown(u);
|
||||
if(l<=T[lson].rig)Update(lson,l,r);
|
||||
if(r>=T[rson].lef)Update(rson,l,r);
|
||||
}
|
||||
}
|
||||
int Query(int u,int index){
|
||||
if(T[u].lef==T[u].rig)return T[u].delta;
|
||||
else {
|
||||
PushDown(u);
|
||||
if(index<=T[lson].rig)return Query(lson,index);
|
||||
else return Query(rson,index);
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int t,n,m;
|
||||
int cnt;
|
||||
scanf("%d",&t);
|
||||
for(int cas=1;cas<=t;cas++){
|
||||
scanf("%d%d",&n,&m);
|
||||
cnt=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
scanf("%d%d",&st[i],&ed[i]);
|
||||
dat[cnt++]=st[i];
|
||||
dat[cnt++]=ed[i];
|
||||
}
|
||||
for(int i=1;i<=m;i++){
|
||||
scanf("%d",&q[i]);
|
||||
dat[cnt++]=q[i];
|
||||
}
|
||||
sort(dat,dat+cnt);
|
||||
cnt=unique(dat,dat+cnt)-dat;
|
||||
Build(1,1,cnt);
|
||||
for(int i=1;i<=n;i++){
|
||||
st[i]=lower_bound(dat,dat+cnt,st[i])-dat+1;
|
||||
ed[i]=lower_bound(dat,dat+cnt,ed[i])-dat+1;
|
||||
Update(1,st[i],ed[i]);
|
||||
}
|
||||
printf("Case #%d:\n",cas);
|
||||
for(int i=1;i<=m;i++){
|
||||
q[i]=lower_bound(dat,dat+cnt,q[i])-dat+1;
|
||||
printf("%d\n",Query(1,q[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
#define maxn 102
|
||||
#define eps 1e-10
|
||||
double g[maxn][maxn];
|
||||
double x[maxn];
|
||||
int n,m,k;
|
||||
void add(int cnt,int i,int j,double val)
|
||||
{
|
||||
int t=i*n+j;
|
||||
if(i==m)
|
||||
{
|
||||
if(j==1)
|
||||
g[cnt][m*n+1]+=-1.0*val;
|
||||
return;
|
||||
}
|
||||
g[cnt][t]+=val;
|
||||
}
|
||||
void gauss(int n,int m)
|
||||
{
|
||||
int row,col,i,j,k;
|
||||
for(row=1,col=1;row<n,col<m;row++,col++)
|
||||
{
|
||||
k=row;
|
||||
for(i=row+1;i<=n;i++)
|
||||
if(fabs(g[i][col])>fabs(g[k][col]))
|
||||
k=i;
|
||||
if(k!=row)
|
||||
{
|
||||
for(i=col; i<=m; i++)
|
||||
swap(g[k][i],g[row][i]);
|
||||
}
|
||||
for(i=row+1; i<=n; i++)
|
||||
{
|
||||
if(fabs(g[i][col])<eps)
|
||||
continue;
|
||||
double t=g[i][col]/g[row][col];
|
||||
g[i][col]=0.0;
|
||||
for(j=col+1;j<=m;j++)
|
||||
g[i][j]-=t*g[row][j];
|
||||
}
|
||||
}
|
||||
for(i=n;i>=1;i--)
|
||||
{
|
||||
x[i]=g[i][m];
|
||||
for(j=i+1;j<=n;j++)
|
||||
x[i]-=x[j]*g[i][j];
|
||||
x[i]/=g[i][i];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,cs,nn=0;
|
||||
scanf("%d",&cs);
|
||||
while(cs--){
|
||||
scanf("%d%d%d",&n,&m,&k);
|
||||
memset(g,0,sizeof(g));
|
||||
int cnt=0;
|
||||
for(i=0;i<m;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
cnt++;
|
||||
add(cnt,i,j,1.0);
|
||||
if(j==1)
|
||||
{
|
||||
add(cnt,i+1,j,-0.25);
|
||||
add(cnt,1,n-2,-0.75);
|
||||
}
|
||||
else if(j==2)
|
||||
{
|
||||
add(cnt,i+1,n-2,-0.25);
|
||||
add(cnt,1,1,-0.25);
|
||||
add(cnt,1,n-1,-0.5);
|
||||
}
|
||||
else if(j==3)
|
||||
{
|
||||
add(cnt,i+1,n-1,-0.25);
|
||||
add(cnt,1,1,-0.25);
|
||||
add(cnt,1,n-1,-0.25);
|
||||
add(cnt,1,n,-0.25);
|
||||
}
|
||||
else if(j==4)
|
||||
{
|
||||
add(cnt,i+1,n,-0.25);
|
||||
add(cnt,1,n,-0.5);
|
||||
add(cnt,1,1,-0.25);
|
||||
}
|
||||
else
|
||||
{
|
||||
add(cnt,i+1,j-3,-0.25);
|
||||
add(cnt,1,j-3,-0.75);
|
||||
}
|
||||
}
|
||||
gauss(cnt,cnt+1);
|
||||
printf("Case #%d: %.6lf\n",++nn,x[k]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const double INF = 1000000000.0;
|
||||
const int maxn = 1010;
|
||||
const double eps = 1e-12;
|
||||
inline double sgn(double x) {return fabs(x)<eps?0:(x>0?1:-1);}
|
||||
struct Point{
|
||||
double x,y;
|
||||
Point(double tx=0,double ty=0){x=tx;y=ty;}
|
||||
bool operator == (const Point& t) const {
|
||||
return sgn(x-t.x)==0 && sgn(y-t.y)==0;
|
||||
}
|
||||
Point operator - (const Point& t) const {
|
||||
Point tmp;
|
||||
tmp.x = x - t.x;
|
||||
tmp.y = y - t.y;
|
||||
return tmp;
|
||||
}
|
||||
}p[maxn],tmp[maxn],pp[maxn],GP;
|
||||
struct Seg{Point s,e;};
|
||||
struct Line {
|
||||
double a, b, c;
|
||||
};
|
||||
double cross(Point a,Point b,Point c){return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);}
|
||||
inline Point intersect(Point x,Point y,double a,double b,double c){
|
||||
double u = fabs(a * x.x + b * x.y + c);
|
||||
double v = fabs(a * y.x + b * y.y + c);
|
||||
return Point( (x.x * v + y.x * u) / (u + v) , (x.y * v + y.y * u) / (u + v) );
|
||||
}
|
||||
int n,ban_tot;
|
||||
void CUT1(double a,double b,double c){
|
||||
int i,tot=0;
|
||||
for(int i = 1; i <= ban_tot; ++i){
|
||||
if(a*p[i].x + b*p[i].y + c >= eps) pp[++tot] = p[i];
|
||||
else {
|
||||
if(a*p[i-1].x + b*p[i-1].y + c > eps){
|
||||
pp[++tot] = intersect(p[i],p[i-1],a,b,c);
|
||||
}
|
||||
if(a*p[i+1].x + b*p[i+1].y + c > eps){
|
||||
pp[++tot] = intersect(p[i],p[i+1],a,b,c);
|
||||
}
|
||||
}
|
||||
} ban_tot=tot;
|
||||
pp[tot+1]=pp[1];pp[0]=pp[tot];
|
||||
memcpy(p,pp,sizeof(pp));
|
||||
}
|
||||
void CUT2(double a,double b,double c){
|
||||
int i,tot=0;
|
||||
for(int i = 1; i <= ban_tot; ++i){
|
||||
if(!(a*p[i].x + b*p[i].y + c > eps) ) pp[++tot] = p[i];
|
||||
else {
|
||||
if(a*p[i-1].x + b*p[i-1].y + c < -eps){
|
||||
pp[++tot] = intersect(p[i],p[i-1],a,b,c);
|
||||
}
|
||||
if(a*p[i+1].x + b*p[i+1].y + c < -eps){
|
||||
pp[++tot] = intersect(p[i],p[i+1],a,b,c);
|
||||
}
|
||||
}
|
||||
} ban_tot=tot;
|
||||
pp[tot+1]=pp[1];pp[0]=pp[tot];
|
||||
memcpy(p,pp,sizeof(pp));
|
||||
}
|
||||
Line Turn(Point s, Point e) {
|
||||
Line ln;
|
||||
ln.a = s.y - e.y;
|
||||
ln.b = e.x - s.x;
|
||||
ln.c = s.x*e.y - e.x*s.y;
|
||||
return ln;
|
||||
}
|
||||
Line make(Point a,Point b)
|
||||
{
|
||||
double x0=(a.x+b.x)/2;
|
||||
double y0=(a.y+b.y)/2;
|
||||
Line tmp=Turn(a,b);
|
||||
Line ans;
|
||||
ans.a=tmp.b;
|
||||
ans.b=-tmp.a;
|
||||
ans.c=tmp.a*y0-tmp.b*x0;
|
||||
return ans;
|
||||
}
|
||||
Line ln[maxn];
|
||||
inline double PPdis(Point a, Point b) {
|
||||
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
inline double PLdis(Point p,Point l1,Point l2){
|
||||
return fabs(cross(p,l1,l2))/PPdis(l1,l2);
|
||||
}
|
||||
double calc(Point *p,int n)
|
||||
{
|
||||
if(n<3) return 0;
|
||||
double area=0,V=0;
|
||||
for(int i=0;i<n;i++) area+=p[(i+1)%n].y*(p[i].x-p[(i+2)%n].x);
|
||||
area/=2;
|
||||
area=fabs(area);
|
||||
double H=10;
|
||||
int pos=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
if(2-p[i].x-p[i].y<H)
|
||||
{
|
||||
H=2-p[i].x-p[i].y;
|
||||
pos=i;
|
||||
}
|
||||
}
|
||||
V+=area*H;
|
||||
for(int i=pos+1;;i++)
|
||||
{
|
||||
int id1=i%n;
|
||||
int id2=(i+1)%n;
|
||||
if(id2==pos) break;
|
||||
double h=PLdis(p[pos],p[id1],p[id2]);
|
||||
double s=((2-p[id1].x-p[id1].y-H) + (2-p[id2].x-p[id2].y-H)) * PPdis(p[id1],p[id2])/2;
|
||||
V+=s*h/3;
|
||||
}
|
||||
return V;
|
||||
}
|
||||
double ans[110];
|
||||
int main(){
|
||||
int t,ca=1,n;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i=1;i<=n;i++) scanf("%lf%lf",&tmp[i].x,&tmp[i].y);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
p[1]=Point(0,0);
|
||||
p[2]=Point(0,1);
|
||||
p[3]=Point(1,1);
|
||||
p[4]=Point(1,0);
|
||||
p[0]=p[4];
|
||||
p[5]=p[1];
|
||||
ban_tot=4;
|
||||
double x0=tmp[i].x,y0=tmp[i].y;
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
if(i==j) continue;
|
||||
Line mid_line = make(tmp[i],tmp[j]);
|
||||
double a=mid_line.a,b=mid_line.b,c=mid_line.c;
|
||||
if(a*x0+b*y0+c >= eps)
|
||||
{
|
||||
CUT1(a,b,c);
|
||||
}
|
||||
else
|
||||
{
|
||||
CUT2(a,b,c);
|
||||
}
|
||||
}
|
||||
double tmpv=calc(p,ban_tot);
|
||||
ans[i]=tmpv;
|
||||
}
|
||||
printf("Case #%d:\n",ca++);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
printf("%.6lf\n",ans[i]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
char map[1010][1010];
|
||||
int lefts[1010][1010],heights[1010][1010],rights[1010][1010];
|
||||
int CountSingle(int n,int m,char sing){
|
||||
int ret=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
if(i==1){
|
||||
int l=0;
|
||||
for(int j=1;j<=m;j++){
|
||||
if(map[i][j]!=sing){
|
||||
heights[i][j]=0;
|
||||
lefts[i][j]=m+1;
|
||||
l=j;
|
||||
}
|
||||
else{
|
||||
heights[i][j]=1;
|
||||
lefts[i][j]=l+1;
|
||||
}
|
||||
}
|
||||
int r=m+1;
|
||||
for(int j=m;j>=1;j--){
|
||||
if(map[i][j]!=sing){
|
||||
rights[i][j]=0;
|
||||
r=j;
|
||||
}
|
||||
else{
|
||||
rights[i][j]=r-1;
|
||||
ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
|
||||
}
|
||||
}
|
||||
}
|
||||
else{
|
||||
int l=0;
|
||||
for(int j=1;j<=m;j++){
|
||||
if(map[i][j]!=sing){
|
||||
heights[i][j]=0;
|
||||
lefts[i][j]=m+1;
|
||||
l=j;
|
||||
}
|
||||
else{
|
||||
if(map[i-1][j]==sing){
|
||||
heights[i][j]=heights[i-1][j]+1;
|
||||
lefts[i][j]=max(lefts[i-1][j],l+1);
|
||||
}
|
||||
else{
|
||||
heights[i][j]=1;
|
||||
lefts[i][j]=l+1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int r=m+1;
|
||||
for(int j=m;j>=1;j--){
|
||||
if(map[i][j]!=sing){
|
||||
rights[i][j]=0;
|
||||
r=j;
|
||||
}
|
||||
else{
|
||||
if(map[i-1][j]==sing){
|
||||
rights[i][j]=min(rights[i-1][j],r-1);
|
||||
ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
|
||||
}
|
||||
else{
|
||||
rights[i][j]=r-1;
|
||||
ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int CountCross(int n,int m){
|
||||
int ret=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
if(i==1){
|
||||
int l=0;
|
||||
for(int j=1;j<=m;j++){
|
||||
if(j==1){
|
||||
heights[i][j]=1;
|
||||
lefts[i][j]=1;
|
||||
}
|
||||
else{
|
||||
if(map[i][j-1]==map[i][j]){
|
||||
lefts[i][j]=j;
|
||||
l=j-1;
|
||||
heights[i][j]=1;
|
||||
}
|
||||
else{
|
||||
lefts[i][j]=l+1;
|
||||
heights[i][j]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int r=m+1;
|
||||
for(int j=m;j>=1;j--){
|
||||
if(j==m){
|
||||
heights[i][j]=1;
|
||||
rights[i][j]=m;
|
||||
}
|
||||
else{
|
||||
if(map[i][j]==map[i][j+1]){
|
||||
heights[i][j]=1;
|
||||
rights[i][j]=j;
|
||||
r=j+1;
|
||||
}
|
||||
else{
|
||||
rights[i][j]=r-1;
|
||||
heights[i][j]=1;
|
||||
}
|
||||
}
|
||||
ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
|
||||
}
|
||||
}
|
||||
else{
|
||||
int l=0;
|
||||
for(int j=1;j<=m;j++){
|
||||
if(j==1){
|
||||
if(map[i][j]!=map[i-1][j]){
|
||||
heights[i][j]=heights[i-1][j]+1;
|
||||
lefts[i][j]=1;
|
||||
}
|
||||
else{
|
||||
heights[i][j]=1;
|
||||
lefts[i][j]=1;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(map[i][j]!=map[i-1][j]){
|
||||
heights[i][j]=heights[i-1][j]+1;
|
||||
if(map[i][j]==map[i][j-1]){
|
||||
lefts[i][j]=j;
|
||||
l=j-1;
|
||||
}
|
||||
else{
|
||||
lefts[i][j]=max(lefts[i-1][j],l+1);
|
||||
}
|
||||
}
|
||||
else{
|
||||
heights[i][j]=1;
|
||||
if(map[i][j]==map[i][j-1]){
|
||||
lefts[i][j]=j;
|
||||
l=j-1;
|
||||
}
|
||||
else{
|
||||
lefts[i][j]=l+1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int r=m+1;
|
||||
for(int j=m;j>=1;j--){
|
||||
if(j==m){
|
||||
if(map[i][j]!=map[i-1][j]){
|
||||
heights[i][j]=heights[i-1][j]+1;
|
||||
rights[i][j]=m;
|
||||
}
|
||||
else{
|
||||
heights[i][j]=1;
|
||||
rights[i][j]=m;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(map[i][j]!=map[i-1][j]){
|
||||
heights[i][j]=heights[i-1][j]+1;
|
||||
if(map[i][j]==map[i][j+1]){
|
||||
rights[i][j]=j;
|
||||
r=j+1;
|
||||
}
|
||||
else{
|
||||
rights[i][j]=min(rights[i-1][j],r-1);
|
||||
}
|
||||
}
|
||||
else{
|
||||
heights[i][j]=1;
|
||||
if(map[i][j]==map[i][j+1]){
|
||||
rights[i][j]=j;
|
||||
r=j+1;
|
||||
}
|
||||
else{
|
||||
rights[i][j]=r-1;
|
||||
}
|
||||
}
|
||||
}
|
||||
ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main(){
|
||||
int ansR,ansB,ansC,kase=0;
|
||||
int T,n,m;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d%d",&n,&m);
|
||||
getchar();
|
||||
for(int i=1;i<=n;i++)
|
||||
gets(map[i]+1);
|
||||
ansR=CountSingle(n,m,'R');
|
||||
ansB=CountSingle(n,m,'B');
|
||||
ansC=CountCross(n,m);
|
||||
cout<<"Case #"<<++kase<<": "<<max(ansR,max(ansB,ansC))<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#include<string>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
int main(){
|
||||
int t,T,i,j,k,n;
|
||||
int sta;
|
||||
double sum[110],ans;
|
||||
int all[110];
|
||||
int ss,num;
|
||||
string str;
|
||||
char sss[10010];
|
||||
map<string,int> m[100];
|
||||
scanf("%d",&T);
|
||||
for(t=1;t<=T;t++){
|
||||
memset(all,0,sizeof(all));
|
||||
memset(sum,0,sizeof(sum));
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%s",str);
|
||||
getline(cin,str);
|
||||
for(j=0;j<str.length() && str[j]==' ';j++);
|
||||
sta=j;
|
||||
for(;j<str.length();j++){
|
||||
if(str[j]==' '){
|
||||
m[i].insert(make_pair(str.substr(sta,j-sta),1));
|
||||
all[i]++;
|
||||
for(;j<str.length() && str[j]==' ';j++);
|
||||
sta=j;
|
||||
if(sta==str.length())break;
|
||||
j--;
|
||||
}
|
||||
}
|
||||
if(sta!=str.length()){
|
||||
m[i].insert(make_pair(str.substr(sta,j-sta),1));
|
||||
all[i]++;
|
||||
}
|
||||
}
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%s",str);
|
||||
getline(cin,str);
|
||||
for(j=0;j<str.length() && str[j]==' ';j++);
|
||||
sta=j;
|
||||
ss=num=0;
|
||||
for(;j<str.length();j++){
|
||||
if(str[j]==' '){
|
||||
num++;
|
||||
if(m[i].find(str.substr(sta,j-sta))!=m[i].end()){
|
||||
ss++;
|
||||
sum[i]+=(double)ss/num;
|
||||
}
|
||||
for(;j<str.length() && str[j]==' ';j++);
|
||||
sta=j;
|
||||
if(sta==str.length())break;
|
||||
j--;
|
||||
}
|
||||
}
|
||||
if(sta!=str.length()){
|
||||
num++;
|
||||
if(m[i].find(str.substr(sta,j-sta))!=m[i].end()){
|
||||
ss++;
|
||||
sum[i]+=(double)ss/num;
|
||||
}
|
||||
}
|
||||
sum[i]/=all[i];
|
||||
}
|
||||
ans=0;
|
||||
for(i=0;i<n;i++)
|
||||
ans+=sum[i];
|
||||
printf("Case #%d: %.6lf\n",t,ans/n);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,231 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-8;
|
||||
int getNumberOnce(char stage[10][10])
|
||||
{
|
||||
bool remove[10][10];
|
||||
memset(remove, false, sizeof(remove));
|
||||
for(int i=0;i<8;++i)
|
||||
{
|
||||
for(int j=0;j<8;++j)
|
||||
{
|
||||
if(i<6)
|
||||
{
|
||||
if(stage[i][j])
|
||||
{
|
||||
if(stage[i][j] == stage[i+1][j])
|
||||
{
|
||||
if(stage[i][j] == stage[i+2][j])
|
||||
{
|
||||
remove[i][j] = true;
|
||||
remove[i+1][j] = true;
|
||||
remove[i+2][j] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(j<6)
|
||||
{
|
||||
if(stage[i][j])
|
||||
{
|
||||
if(stage[i][j] == stage[i][j+1])
|
||||
{
|
||||
if(stage[i][j] == stage[i][j+2])
|
||||
{
|
||||
remove[i][j] = true;
|
||||
remove[i][j+1] = true;
|
||||
remove[i][j+2] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int num = 0;
|
||||
for(int i=0;i<8;++i)
|
||||
{
|
||||
for(int j=0;j<8;++j)
|
||||
{
|
||||
if(remove[i][j])
|
||||
{
|
||||
stage[i][j] = 0;
|
||||
++ num;
|
||||
}
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
void fallDown(char stage[10][10])
|
||||
{
|
||||
for(int j=0;j<8;++j)
|
||||
{
|
||||
int k = 7;
|
||||
for(int i=7;i>=0;--i)
|
||||
{
|
||||
if(stage[i][j])
|
||||
{
|
||||
stage[k--][j] = stage[i][j];
|
||||
}
|
||||
}
|
||||
for(int i=k;i>=0;--i)
|
||||
{
|
||||
stage[i][j] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
int getNumber(char stage[10][10])
|
||||
{
|
||||
int num = 0;
|
||||
while(true)
|
||||
{
|
||||
int temp = getNumberOnce(stage);
|
||||
if(temp == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
num += temp;
|
||||
fallDown(stage);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
char stage[10][10];
|
||||
bool simpleJudge()
|
||||
{
|
||||
char temp[10][10];
|
||||
memcpy(temp, stage, sizeof(temp));
|
||||
return getNumber(temp) >= 8;
|
||||
}
|
||||
struct Point
|
||||
{
|
||||
int x, y;
|
||||
};
|
||||
int getPow5(int x)
|
||||
{
|
||||
int res = 1;
|
||||
while(x--)
|
||||
{
|
||||
res *= 5;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
double completeJudge(char stage[10][10], int remain)
|
||||
{
|
||||
char temp[10][10];
|
||||
memcpy(temp, stage, sizeof(temp));
|
||||
int num = getNumberOnce(temp);
|
||||
if(num >= remain)
|
||||
{
|
||||
return 1.0;
|
||||
}
|
||||
if(num == 0)
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
remain -= num;
|
||||
fallDown(temp);
|
||||
Point stack[8];
|
||||
int top = 0;
|
||||
for(int i=0;i<8;++i)
|
||||
{
|
||||
for(int j=0;j<8;++j)
|
||||
{
|
||||
if(!temp[i][j])
|
||||
{
|
||||
stack[top].x = i;
|
||||
stack[top].y = j;
|
||||
++ top;
|
||||
}
|
||||
}
|
||||
}
|
||||
int total = getPow5(top);
|
||||
double ret = 0.0;
|
||||
for(int i=0;i<total;++i)
|
||||
{
|
||||
int bit = i;
|
||||
for(int j=0;j<top;++j)
|
||||
{
|
||||
temp[stack[j].x][stack[j].y] = '0' + (bit % 5);
|
||||
bit /= 5;
|
||||
}
|
||||
ret += completeJudge(temp, remain);
|
||||
}
|
||||
return ret / total;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int caseNumber;
|
||||
scanf("%d", &caseNumber);
|
||||
for(int cas=1;cas<=caseNumber;++cas)
|
||||
{
|
||||
for(int i=0;i<8;++i)
|
||||
{
|
||||
scanf("%s", stage[i]);
|
||||
}
|
||||
double ans = 0.0;
|
||||
bool end = false;
|
||||
for(int i=0;i<8 && !end;++i)
|
||||
{
|
||||
for(int j=0;j<8 && !end;++j)
|
||||
{
|
||||
if(i!=7)
|
||||
{
|
||||
swap(stage[i][j], stage[i+1][j]);
|
||||
if(simpleJudge())
|
||||
{
|
||||
ans = 1.0;
|
||||
end = true;
|
||||
}
|
||||
swap(stage[i][j], stage[i+1][j]);
|
||||
}
|
||||
if(j!=7)
|
||||
{
|
||||
swap(stage[i][j], stage[i][j+1]);
|
||||
if(simpleJudge())
|
||||
{
|
||||
ans = 1.0;
|
||||
end = true;
|
||||
}
|
||||
swap(stage[i][j], stage[i][j+1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!end)
|
||||
{
|
||||
double temp;
|
||||
for(int i=0;i<8 && !end;++i)
|
||||
{
|
||||
for(int j=0;j<8 && !end;++j)
|
||||
{
|
||||
if(i!=7)
|
||||
{
|
||||
swap(stage[i][j], stage[i+1][j]);
|
||||
temp = completeJudge(stage, 8);
|
||||
ans = max(ans, temp);
|
||||
swap(stage[i][j], stage[i+1][j]);
|
||||
}
|
||||
if(ans > 1.0 - eps)
|
||||
{
|
||||
ans = 1.0;
|
||||
end = true;
|
||||
}
|
||||
if(j!=7)
|
||||
{
|
||||
swap(stage[i][j], stage[i][j+1]);
|
||||
temp = completeJudge(stage, 8);
|
||||
ans = max(ans, temp);
|
||||
swap(stage[i][j], stage[i][j+1]);
|
||||
}
|
||||
if(ans > 1.0 - eps)
|
||||
{
|
||||
ans = 1.0;
|
||||
end = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %.3lf\n", cas, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#define MAXN 1005
|
||||
using namespace std;
|
||||
int N, G[MAXN][MAXN], c[MAXN], idx;
|
||||
int dgn[MAXN];
|
||||
int l[MAXN][MAXN], r[MAXN][MAXN], u[MAXN][MAXN], d[MAXN][MAXN];
|
||||
struct Node
|
||||
{
|
||||
int x, sign, key;
|
||||
bool operator < (Node temp) const
|
||||
{
|
||||
if (x != temp.x) {
|
||||
return x < temp.x;
|
||||
}
|
||||
else {
|
||||
return sign < temp.sign;
|
||||
}
|
||||
}
|
||||
}p[MAXN<<1];
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x & -x;
|
||||
}
|
||||
void addpoint(int a, int b)
|
||||
{
|
||||
++idx;
|
||||
p[idx].x = a, p[idx].sign = 0;
|
||||
p[idx].key = a;
|
||||
++idx;
|
||||
p[idx].x = b, p[idx].sign = 1;
|
||||
p[idx].key = a;
|
||||
}
|
||||
void add(int x)
|
||||
{
|
||||
for (int i = x; i <= N; i += lowbit(i)) {
|
||||
c[i] += 1;
|
||||
}
|
||||
}
|
||||
int sum(int x)
|
||||
{
|
||||
int ret = 0;
|
||||
for (int i = x; i > 0; i -= lowbit(i)) {
|
||||
ret += c[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
int ret = 0;
|
||||
for (int i = N; i >= 1; --i) {
|
||||
idx = -1;
|
||||
for (int j = 1; j <= (N-i+1); ++j) {
|
||||
if (G[i+j-1][j]) {
|
||||
addpoint(j, j+min(r[i+j-1][j], d[i+j-1][j])-1);
|
||||
dgn[j] = j - min(u[i+j-1][j], l[i+j-1][j])+1;
|
||||
}
|
||||
}
|
||||
if (idx == -1) { continue; }
|
||||
sort(p, p+idx+1);
|
||||
memset(c, 0, sizeof (c));
|
||||
for (int k = 0; k <= idx; ++k) {
|
||||
if (!p[k].sign) {
|
||||
ret -= sum(p[k].key);
|
||||
add(dgn[p[k].x]);
|
||||
}
|
||||
else {
|
||||
ret += sum(p[k].key);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int j = 2; j <= N; ++j) {
|
||||
idx = -1;
|
||||
for (int i = 1; i <= (N-j+1); ++i) {
|
||||
if (G[i][j+i-1]) {
|
||||
addpoint(i, i+min(r[i][j+i-1], d[i][j+i-1])-1);
|
||||
dgn[i] = i - min(u[i][j+i-1], l[i][j+i-1])+1;
|
||||
}
|
||||
}
|
||||
if (idx == -1) { continue; }
|
||||
sort(p, p+idx+1);
|
||||
memset(c, 0, sizeof (c));
|
||||
for (int k = 0; k <= idx; ++k) {
|
||||
if (!p[k].sign) {
|
||||
ret -= sum(p[k].key);
|
||||
add(dgn[p[k].x]);
|
||||
}
|
||||
else {
|
||||
ret += sum(p[k].key);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, ca = 0;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d", &N);
|
||||
memset(d, 0, sizeof (d));
|
||||
memset(r, 0, sizeof (r));
|
||||
for (int i = 1; i<= N; ++i) {
|
||||
for (int j = 1; j <= N; ++j) {
|
||||
scanf("%d", &G[i][j]);
|
||||
if (G[i][j]) {
|
||||
u[i][j] = G[i-1][j] ? u[i-1][j] + 1 : 1;
|
||||
l[i][j] = G[i][j-1] ? l[i][j-1] + 1 : 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = N; i >= 1; --i) {
|
||||
for (int j = N; j >= 1; --j) {
|
||||
if (G[i][j]) {
|
||||
d[i][j] = G[i+1][j] ? d[i+1][j] + 1 : 1;
|
||||
r[i][j] = G[i][j+1] ? r[i][j+1] + 1 : 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: %d\n", ++ca, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
typedef __int64 LL ;
|
||||
const LL Mod = 1000000007LL ;
|
||||
const int m = (1 << 8) ;
|
||||
const int mm = 70 ;
|
||||
bool ok[m] ;
|
||||
int a[8] , N ;
|
||||
int min[m] ;
|
||||
struct Matrix{
|
||||
LL mat[mm][mm] ;
|
||||
void init(){
|
||||
memset( mat, 0 ,sizeof(mat) ) ;
|
||||
}
|
||||
}M[31] , res ,mid ;
|
||||
LL ans[mm] ;
|
||||
bool is_ok(int s){
|
||||
if( s==0 ) return true ;
|
||||
if( s==m-1 ) return true ;
|
||||
int val[8] ;
|
||||
int i ;
|
||||
for(i=0;i<8;i++)
|
||||
if( s&a[i] ) val[i] = 1 ;
|
||||
else val[i] = 0;
|
||||
i = 0 ;
|
||||
while( val[i] ) ++ i ;
|
||||
for(int ii=0;ii<8;ii++ ){
|
||||
if( val[ (ii+i)%8 ] == 0 ) continue ;
|
||||
if( ii+1<8 && val[ (ii+i+1)%8 ] ){
|
||||
ii ++ ;
|
||||
}
|
||||
else return false ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
int getmin( int n ){
|
||||
int val[8] ;
|
||||
for(int i=0;i<8;i++) {
|
||||
if( n&a[i] ) val[i] = 1 ;
|
||||
else val[i] = 0 ;
|
||||
}
|
||||
int v = 0 ;
|
||||
int res = n ;
|
||||
for(int ii=0;ii<8;ii++)
|
||||
if( val[ (2+ii)%8 ] ) v |= a[ ii ] ;
|
||||
if( res > v ) res = v ;
|
||||
v = 0 ;
|
||||
for(int ii=0;ii<8;ii++)
|
||||
if( val[ (4+ii)%8 ] ) v |= a[ ii ] ;
|
||||
if( res > v ) res =v ;
|
||||
v = 0 ;
|
||||
for(int ii=0;ii<8;ii++)
|
||||
if( val[ (6+ii)%8 ] ) v |= a[ ii ] ;
|
||||
if( res > v ) res =v ;
|
||||
return res ;
|
||||
}
|
||||
std::map<int , int> mp ;
|
||||
bool vis[m + 10][m + 10] ;
|
||||
void deal(int sou , int to){
|
||||
int val[8] ;
|
||||
for(int i=0;i<8;i++){
|
||||
if( to&a[i] ) val[i] = 1 ;
|
||||
else val[i] = 0 ;
|
||||
}
|
||||
LL v1 , v2 ;
|
||||
v1 = sou ;
|
||||
for(int j=0; j<=6;j+=2 ){
|
||||
v2 = 0 ;
|
||||
for(int jj=0;jj<8;jj++){
|
||||
if( val[ (j+jj)%8 ] ) v2 |= a[jj] ;
|
||||
}
|
||||
if( ( v1|v2 )==m-1 && ok[ v1&v2 ] && !vis[v1][v2] ){
|
||||
M[0].mat[ mp[ min[v1] ] ][ mp[ min[v2] ] ] ++ ;
|
||||
vis[v1][v2] = 1 ;
|
||||
}
|
||||
}
|
||||
}
|
||||
void build_matrix(){
|
||||
M[0].init() ;
|
||||
memset( vis , 0 , sizeof(vis) );
|
||||
std::map<int, int>::iterator it1 ,it2 ;
|
||||
for( it1 = mp.begin() ; it1!=mp.end() ; it1++ ){
|
||||
for( it2=mp.begin() ; it2!=mp.end() ; it2++ ){
|
||||
deal( it1->first , it2->first ) ;
|
||||
}
|
||||
}
|
||||
M[0].mat[mm-1][mm-1] = 2 ;
|
||||
for(int ii=1;ii<=30;ii++){
|
||||
for(int i=0;i<mm;i++){
|
||||
for(int j=0;j<mm;j++){
|
||||
mid.mat[i][j] = 0 ;
|
||||
for(int k=0;k<mm;k++){
|
||||
mid.mat[i][j] = ( mid.mat[i][j] + M[ii-1].mat[i][k] * M[ii-1].mat[k][j] % Mod ) % Mod ;
|
||||
}
|
||||
}
|
||||
}
|
||||
M[ii] = mid ;
|
||||
}
|
||||
}
|
||||
void init(){
|
||||
a[0] = 1 ;
|
||||
for(int i=1;i<8;i++) a[i] = a[i-1]<<1 ;
|
||||
for(int i=0;i<m;i++) min[i] = getmin(i) ;
|
||||
for(int i=0;i<m;i++){
|
||||
ok[i] = is_ok( i ) ;
|
||||
mp[ min[i] ] = 1 ;
|
||||
}
|
||||
std::map<int,int>::iterator it = mp.begin() ;
|
||||
int ss = 0 ;
|
||||
for( it ; it != mp.end(); it ++ ){
|
||||
it->second = ss ++ ;
|
||||
}
|
||||
build_matrix() ;
|
||||
}
|
||||
void calc( int n ){
|
||||
memset( ans , 0 , sizeof(ans) ) ;
|
||||
int jj = 0 ;
|
||||
ans[ mm-1 ] = 1 ;
|
||||
LL CC[mm] ;
|
||||
while( n ){
|
||||
if( n&1 ){
|
||||
for(int i=0;i<mm;i++){
|
||||
CC[i] = 0;
|
||||
for(int j=0;j<mm;j++){
|
||||
CC[i] = ( CC[i] + ans[j] * M[jj].mat[i][j]% Mod ) % Mod ;
|
||||
}
|
||||
}
|
||||
for(int i=0;i<mm;i++) ans[i] = CC[i] ;
|
||||
}
|
||||
n >>= 1 ; jj ++ ;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
init() ;
|
||||
int T ;scanf("%d",&T) ;
|
||||
int cas = 0 ;
|
||||
while( T-- ){
|
||||
scanf("%d",&N) ;
|
||||
calc(N + 1) ;
|
||||
printf("Case %d: %I64d\n",++cas,ans[0] ) ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 999999999
|
||||
using namespace std;
|
||||
const int MAX=100000+10;
|
||||
char s[MAX*2];
|
||||
int ne[MAX];
|
||||
void get_next(char *a,int len){
|
||||
int i=-1,j=0;
|
||||
ne[0]=-1;
|
||||
while(j<len){
|
||||
if(i == -1 || a[i] == a[j])ne[++j]=++i;
|
||||
else i=ne[i];
|
||||
}
|
||||
}
|
||||
void get_extend(char *a,int len){
|
||||
int k=0,i=1;
|
||||
ne[0]=len;
|
||||
while(k+1<len && a[k] == a[k+1])++k;
|
||||
ne[1]=k;
|
||||
k=1;
|
||||
while(++i<len/2){
|
||||
int maxr=k+ne[k]-1;
|
||||
ne[i]=min(ne[i-k],max(maxr-i+1,0));
|
||||
while(i+ne[i]<len && a[ne[i]] == a[i+ne[i]])++ne[i];
|
||||
if(i+ne[i]>k+ne[k])k=i;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int t,num=0;
|
||||
cin>>t;
|
||||
while(t--){
|
||||
scanf("%s",s);
|
||||
int len=strlen(s);
|
||||
get_next(s,len);
|
||||
int temp=len%(len-ne[len]) == 0?len/(len-ne[len]):1;
|
||||
for(int i=0;i<=len;++i)s[i+len]=s[i];
|
||||
get_extend(s,len+len);
|
||||
int a=0,b=0,c=0;
|
||||
for(int i=0;i<len;++i){
|
||||
if(ne[i]>=len)++b;
|
||||
else if(s[ne[i]]<s[i+ne[i]])++c;
|
||||
else ++a;
|
||||
}
|
||||
cout<<"Case "<<++num<<": "<<a/temp<<' '<<b/temp<<' '<<c/temp<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
int n;
|
||||
__int64 que[5][210],a[41000],b[41000];
|
||||
int cmp(const void*a,const void*b)
|
||||
{
|
||||
if(*(__int64 *)a-*(__int64 *)b > 0)
|
||||
return 1;
|
||||
return -1;
|
||||
}
|
||||
void fun()
|
||||
{
|
||||
int i,f,ji=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(f=0;f<n;f++)
|
||||
{
|
||||
a[ji]=que[0][i]+que[1][f];
|
||||
ji++;
|
||||
}
|
||||
}
|
||||
qsort(a,n*n,sizeof(a[0]),cmp);
|
||||
ji=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(f=0;f<n;f++)
|
||||
{
|
||||
b[ji]=que[2][i]+que[3][f];
|
||||
ji++;
|
||||
}
|
||||
}
|
||||
qsort(b,n*n,sizeof(b[0]),cmp);
|
||||
}
|
||||
int sea(__int64 x)
|
||||
{
|
||||
int head=0,tail=n*n-1;
|
||||
while(1)
|
||||
{
|
||||
if(x == a[head]+b[tail])
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
if(a[head]+b[tail] > x)
|
||||
{
|
||||
tail--;
|
||||
if(-1 == tail)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
head++;
|
||||
if(n*n == head)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,num,f,g;
|
||||
scanf("%d",&num);
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(f=0;f<5;f++)
|
||||
{
|
||||
for(g=0;g<n;g++)
|
||||
{
|
||||
scanf("%I64d",&que[f][g]);
|
||||
}
|
||||
}
|
||||
fun();
|
||||
for(g=0;g<n;g++)
|
||||
{
|
||||
if(1 == sea(-que[4][g]))
|
||||
{
|
||||
printf("Yes\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(g == n)
|
||||
{
|
||||
printf("No\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#include<cmath>
|
||||
#define LL unsigned long long
|
||||
#define eps 1e-6
|
||||
#define zero(a) fabs(a)<eps
|
||||
using namespace std;
|
||||
LL get_eular(LL m){
|
||||
LL ret=1;
|
||||
for(LL i=2;i*i<=m;i++)
|
||||
if(m%i==0){
|
||||
ret*=i-1;
|
||||
m/=i;
|
||||
while(m%i==0){
|
||||
m/=i;
|
||||
ret*=i;
|
||||
}
|
||||
}
|
||||
if(m>1)
|
||||
ret*=m-1;
|
||||
return ret;
|
||||
}
|
||||
LL PowMod(LL a,LL b,LL MOD){
|
||||
LL ret=1;
|
||||
while(b){
|
||||
if(b&1)
|
||||
ret=(ret*a)%MOD;
|
||||
a=(a*a)%MOD;
|
||||
b>>=1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
LL b,p,m,ring[100005];
|
||||
int main(){
|
||||
int t,cas=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%I64u%I64u%I64u",&b,&p,&m);
|
||||
printf("Case #%d: ",++cas);
|
||||
if(p==1){
|
||||
if(m==18446744073709551615ULL)
|
||||
printf("18446744073709551616\n");
|
||||
else
|
||||
printf("%I64u\n",m+1);
|
||||
continue;
|
||||
}
|
||||
LL i=0,phi=get_eular(p),fac=1,ans=0;
|
||||
for(i=0;i<=m&&fac<=phi;i++){
|
||||
if(PowMod(i,fac,p)==b)
|
||||
ans++;
|
||||
fac*=i+1;
|
||||
}
|
||||
fac=fac%phi;
|
||||
for(;i<=m&&fac;i++){
|
||||
if(PowMod(i,fac+phi,p)==b)
|
||||
ans++;
|
||||
fac=(fac*(i+1))%phi;
|
||||
}
|
||||
if(i<=m){
|
||||
LL cnt=0;
|
||||
for(int j=0;j<p;j++){
|
||||
ring[j]=PowMod(i+j,phi,p);
|
||||
if(ring[j]==b)
|
||||
cnt++;
|
||||
}
|
||||
LL idx=(m-i+1)/p;
|
||||
ans+=cnt*idx;
|
||||
LL remain=(m-i+1)%p;
|
||||
for(int j=0;j<remain;j++)
|
||||
if(ring[j]==b)
|
||||
ans++;
|
||||
}
|
||||
printf("%I64u\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int n;
|
||||
double f[1<<20], p[25];
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d", &n)!=EOF)
|
||||
{
|
||||
for(int i=0; i<n; i++)
|
||||
scanf("%lf", &p[i]);
|
||||
int all=(1<<n)-1;
|
||||
f[all]=0;
|
||||
for(int s=all-1; s>=0; s--)
|
||||
{
|
||||
double temp=0;
|
||||
f[s]=1;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
if(s&(1<<i)) continue;
|
||||
f[s]+=f[s|(1<<i)]*p[i];
|
||||
temp+=p[i];
|
||||
}
|
||||
f[s]/=temp;
|
||||
}
|
||||
printf("%lf\n", f[0]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
#define V 200
|
||||
int n,m;
|
||||
bool c[V][V];
|
||||
int x[V];
|
||||
bool flag[V];
|
||||
void hamilton()
|
||||
{
|
||||
int i, k;
|
||||
bool s[V];
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
x[i] = -1;
|
||||
s[i] = false;
|
||||
}
|
||||
k = 1;
|
||||
s[0] = true;
|
||||
x[0] = 0;
|
||||
while(k >= 0)
|
||||
{
|
||||
x[k]++;
|
||||
while(x[k] < n)
|
||||
if(!s[x[k]] && c[x[k - 1]][x[k]])
|
||||
break;
|
||||
else
|
||||
x[k]++;
|
||||
if((x[k] < n) && (k != n - 1))
|
||||
{
|
||||
s[x[k]] = true;
|
||||
k++;
|
||||
}
|
||||
else if((x[k] < n) && k == n - 1 && c[x[k]][x[0]])
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
x[k] = -1;
|
||||
k--;
|
||||
s[x[k]] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a,b;
|
||||
while(cin >> n >> m){
|
||||
memset(c,0,sizeof(c));
|
||||
memset(flag,0,sizeof(flag));
|
||||
memset(x,0,sizeof(x));
|
||||
for(int i=0;i<m;i++){
|
||||
cin >> a >> b;
|
||||
c[a-1][b-1]=c[b-1][a-1]=true;
|
||||
}
|
||||
hamilton();
|
||||
bool f=0;
|
||||
for(int i=0;i<n;i++){
|
||||
flag[x[i]]=1;
|
||||
}
|
||||
for(int i=0;i<n;i++){
|
||||
if(!flag[i]) f=1;
|
||||
}
|
||||
if(f) cout <<"no solution" <<endl;
|
||||
else{
|
||||
for(int i=0;i<n;i++){
|
||||
if(i==n-1) cout << x[i]+1 <<endl;
|
||||
else cout << x[i]+1 <<" ";
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,186 @@
|
|||
#pragma comment(linker, "/STACK:102400000,102400000")
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
using namespace std;
|
||||
const int N=200005;
|
||||
#define Log 22
|
||||
struct Edge
|
||||
{
|
||||
int v;
|
||||
Edge *nxt;
|
||||
}memo[N*10],*cur,*h_bef[N],*h_aft[N];
|
||||
void addEdge(int u,int v,Edge* head[])
|
||||
{
|
||||
cur->v=v; cur->nxt=head[u];
|
||||
head[u]=cur++;
|
||||
}
|
||||
int bnum,bn[N];
|
||||
vector<int> block[N];
|
||||
bool iscut[N];
|
||||
bool vis[N];
|
||||
stack<int> stk;
|
||||
int dfn[N],low[N],son_root,idx;
|
||||
int lab[N],id[N],son[N],fa[N];
|
||||
int dp[N][Log],dep[N];
|
||||
void tarjan(int pt_u,int pt_pre)
|
||||
{
|
||||
stack<int> stk_tar;
|
||||
stk_tar.push(pt_u); fa[pt_u]=pt_pre;
|
||||
while(stk_tar.size())
|
||||
{
|
||||
int u=stk_tar.top();
|
||||
int pre=fa[u];
|
||||
if(dfn[u]==0) dfn[u]=low[u]=++idx,stk.push(u);
|
||||
Edge* it;
|
||||
for(it=h_bef[u];it;it=it->nxt)
|
||||
{
|
||||
int v=it->v;
|
||||
if(v==pre) continue;
|
||||
if(fa[v]==-1)
|
||||
{
|
||||
fa[v]=u; stk_tar.push(v);
|
||||
h_bef[u]=it;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(fa[v]==u)
|
||||
{
|
||||
low[u]=min(low[u],low[v]);
|
||||
if(dfn[u]<=low[v])
|
||||
{
|
||||
if(pre==-1) son_root++;
|
||||
else iscut[u]=1;
|
||||
while(1)
|
||||
{
|
||||
int top=stk.top(); stk.pop();
|
||||
block[bnum].push_back(top);
|
||||
if(top==v) break;
|
||||
}
|
||||
block[bnum].push_back(u);
|
||||
bnum++;
|
||||
}
|
||||
}
|
||||
else low[u]=min(low[u],dfn[v]);
|
||||
}
|
||||
}
|
||||
if(it==NULL) stk_tar.pop();
|
||||
}
|
||||
}
|
||||
void dfs(int u,int pre,int cnt,int iid)
|
||||
{
|
||||
dep[u]=dep[ dp[u][0] ]+1;
|
||||
for(int i=1;i<Log;i++) dp[u][i]= dp[ dp[u][i-1] ][ i-1 ];
|
||||
id[u]=iid; son[u]=cnt+bn[u];
|
||||
for(Edge* it=h_aft[u];it;it=it->nxt)
|
||||
{
|
||||
int v=it->v;
|
||||
if(v!=pre)
|
||||
{
|
||||
dp[v][0]=u;
|
||||
dfs(v,u,son[u],iid);
|
||||
}
|
||||
}
|
||||
}
|
||||
int lca(int u,int v)
|
||||
{
|
||||
if(dep[u]<dep[v]) swap(u,v);
|
||||
for(int st=(1<<(Log-1)),i=Log-1;i>=0;st>>=1,i--)
|
||||
{
|
||||
if(st<=dep[u]-dep[v])
|
||||
{
|
||||
u=dp[u][i];
|
||||
}
|
||||
}
|
||||
if(u==v) return u;
|
||||
for(int i=Log-1;i>=0;i--)
|
||||
{
|
||||
if(dp[u][i]!=dp[v][i])
|
||||
{
|
||||
u=dp[u][i];
|
||||
v=dp[v][i];
|
||||
}
|
||||
}
|
||||
return dp[u][0];
|
||||
}
|
||||
void init()
|
||||
{
|
||||
cur=memo;
|
||||
memset(h_bef,0,sizeof(h_bef));
|
||||
memset(h_aft,0,sizeof(h_aft));
|
||||
memset(dp,0,sizeof(dp));
|
||||
bnum=0; idx=0; son_root=0;
|
||||
while(stk.size()) stk.pop();
|
||||
for(int i=0;i<N;i++)
|
||||
{
|
||||
block[i].clear();
|
||||
dfn[i]=0; low[i]=0; lab[i]=-1;
|
||||
id[i]=i; iscut[i]=0; bn[i]=0;
|
||||
son[i]=0; dep[i]=0; vis[i]=0;
|
||||
fa[i]=-1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,Q,t_cnt=0;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
init();
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
int u,v; scanf("%d%d",&u,&v);
|
||||
addEdge(u,v,h_bef);
|
||||
addEdge(v,u,h_bef);
|
||||
}
|
||||
for(int i=0;i<n;i++) if(dfn[i]==0)
|
||||
{
|
||||
son_root=0;
|
||||
tarjan(i,-2);
|
||||
if(son_root>1) iscut[i]=1;
|
||||
}
|
||||
int k=0;
|
||||
for(int i=0;i<n;i++) if(iscut[i])
|
||||
{
|
||||
lab[i]=k; bn[k]=1; k++;
|
||||
}
|
||||
for(int i=0;i<bnum;i++)
|
||||
{
|
||||
for(int j=0;j<(int)block[i].size();j++)
|
||||
{
|
||||
int u=block[i][j];
|
||||
if(iscut[u])
|
||||
{
|
||||
addEdge(lab[u],k,h_aft);
|
||||
addEdge(k,lab[u],h_aft);
|
||||
}
|
||||
else lab[u]=k;
|
||||
}
|
||||
bn[k]=(int)block[i].size();
|
||||
k++;
|
||||
}
|
||||
for(int i=0;i<k;i++) if(dep[i]==0) dfs(i,-1,0,i);
|
||||
scanf("%d",&Q);
|
||||
printf("Case #%d:\n",++t_cnt);
|
||||
while(Q--)
|
||||
{
|
||||
int s,t; scanf("%d%d",&s,&t);
|
||||
if(s==t) printf("%d\n",n-1);
|
||||
else if(lab[s]==-1||lab[t]==-1||id[lab[s]]!=id[lab[t]]) printf("%d\n",n);
|
||||
else
|
||||
{
|
||||
s=lab[s]; t=lab[t];
|
||||
int parent=lca(s,t);
|
||||
int cnt=son[s]+son[t]-2*son[parent]+bn[parent];
|
||||
int len=dep[s]+dep[t]-2*dep[parent];
|
||||
int ans=cnt-len;
|
||||
printf("%d\n",n-ans);
|
||||
}
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include"iostream"
|
||||
#include"cstdio"
|
||||
#include"cstring"
|
||||
using namespace std;
|
||||
const int N=1000010;
|
||||
int ltr[N<<2];
|
||||
char s[2][N];
|
||||
void build(int l,int r,int k)
|
||||
{
|
||||
if(l==r)
|
||||
{
|
||||
if(s[0][l]==s[1][l]) ltr[k]=1;
|
||||
else ltr[k]=0;
|
||||
return ;
|
||||
}
|
||||
int mid=(l+r)>>1;
|
||||
int l_son=k<<1;
|
||||
int r_son=l_son+1;
|
||||
build(l,mid,l_son);
|
||||
build(mid+1,r,r_son);
|
||||
ltr[k]=ltr[l_son];
|
||||
if(ltr[l_son]==mid-l+1) ltr[k]+=ltr[r_son];
|
||||
}
|
||||
void update(int l,int r,int z,int aim,char c,int k)
|
||||
{
|
||||
if(l==r)
|
||||
{
|
||||
s[z][aim]=c;
|
||||
ltr[k]=s[0][aim]==s[1][aim];
|
||||
return ;
|
||||
}
|
||||
int mid=(l+r)>>1;
|
||||
int l_son=k<<1;
|
||||
int r_son=l_son+1;
|
||||
if(aim<=mid)update(l,mid,z,aim,c,l_son);
|
||||
else update(mid+1,r,z,aim,c,r_son);
|
||||
ltr[k]=ltr[l_son];
|
||||
if(ltr[l_son]==mid-l+1) ltr[k]+=ltr[r_son];
|
||||
}
|
||||
int find(int l,int r,int aim,int k)
|
||||
{
|
||||
if(l==aim) return ltr[k];
|
||||
int mid=(l+r)>>1;
|
||||
int l_son=k<<1;
|
||||
int r_son=l_son+1;
|
||||
int ans;
|
||||
if(aim<=mid)
|
||||
{
|
||||
ans=find(l,mid,aim,l_son);
|
||||
if(ans==mid-aim+1) ans+=find(mid+1,r,mid+1,r_son);
|
||||
}
|
||||
else ans=find(mid+1,r,aim,r_son);
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,Case;
|
||||
int i;
|
||||
int len,q;
|
||||
int x,a,b;
|
||||
char c[10];
|
||||
cin>>T;
|
||||
for(Case=1;Case<=T;Case++)
|
||||
{
|
||||
scanf("%s%s",s[0]+1,s[1]+1);
|
||||
i=1;
|
||||
while(s[0][i] && s[1][i]) i++;
|
||||
len=i-1;
|
||||
i=1;
|
||||
build(1,len,1);
|
||||
cin>>q;
|
||||
printf("Case %d:\n",Case);
|
||||
while(q--)
|
||||
{
|
||||
scanf("%d",&x);
|
||||
if(x==1)
|
||||
{
|
||||
scanf("%d%d%s",&a,&b,c);
|
||||
if(b+1>len) continue;
|
||||
update(1,len,a-1,b+1,c[0],1);
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d",&b);
|
||||
if(b+1>len) printf("0\n");
|
||||
else printf("%d\n",find(1,len,b+1,1));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#include<set>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
const int inf = 100000;
|
||||
const int maxn = 101;
|
||||
vector<int> edge[maxn];
|
||||
int a[maxn],b[maxn];
|
||||
int f[maxn][2],g[maxn][2];
|
||||
void dfs(int u,int fa)
|
||||
{
|
||||
f[u][0]=0;
|
||||
g[u][0]=0;
|
||||
int sz=edge[u].size();
|
||||
int m1=inf,m2=inf;
|
||||
bool leaf=true;
|
||||
for(int i=0;i<sz;i++)
|
||||
{
|
||||
int v=edge[u][i];
|
||||
if(v==fa) continue;
|
||||
dfs(v,u);
|
||||
leaf=false;
|
||||
int tmp=min(f[v][0],g[v][1]);
|
||||
f[u][0]+=tmp;
|
||||
m1=min(m1,f[v][1]-tmp);
|
||||
tmp=min(g[v][0],f[v][1]);
|
||||
g[u][0]+=tmp;
|
||||
m2=min(m2,g[v][1]-tmp);
|
||||
}
|
||||
if(leaf)
|
||||
{
|
||||
f[u][1]=a[u];
|
||||
f[u][0]=a[u]/2;
|
||||
g[u][1]=b[u];
|
||||
g[u][0]=b[u]/2;
|
||||
}
|
||||
else
|
||||
{
|
||||
f[u][1]=f[u][0] + min(a[u],m1+a[u]/2);
|
||||
f[u][0]+=a[u]/2;
|
||||
g[u][1]=g[u][0] + min(b[u],m2+b[u]/2);
|
||||
g[u][0]+=b[u]/2;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for(int i=0;i<=n;i++) edge[i].clear();
|
||||
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
|
||||
for(int i=1;i<=n;i++) scanf("%d",&b[i]);
|
||||
for(int i=1,u,v;i<n;i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
edge[u].push_back(v);
|
||||
edge[v].push_back(u);
|
||||
}
|
||||
dfs(1,0);
|
||||
printf("%d\n",min(f[1][1],g[1][1]));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<vector>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int sigma_size=26;
|
||||
const int N=200+100;
|
||||
const int MAXN=40000+100;
|
||||
const double eps=1e-8;
|
||||
const int inf=0x3fffffff;
|
||||
const int mod=1000000000+7;
|
||||
#define L(x) (x<<1)
|
||||
#define R(x) (x<<1|1)
|
||||
int n,T;
|
||||
int dp[MAXN],res[MAXN],st[MAXN];
|
||||
struct node{
|
||||
int x,y,t,val;
|
||||
}p[N];
|
||||
vector<int>G[N];
|
||||
bool judge(node a,node b){
|
||||
return a.x*b.y == b.x*a.y;
|
||||
}
|
||||
bool cmp(int a,int b){
|
||||
return p[a].x*p[a].x+p[a].y*p[a].y<p[b].x*p[b].x+p[b].y*p[b].y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int kase=0;
|
||||
while(~scanf("%d%d",&n,&T)){
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d%d%d%d",&p[i].x,&p[i].y,&p[i].t,&p[i].val);
|
||||
int cnt=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
int flag=1;
|
||||
for(int j=0;j<cnt;j++){
|
||||
if(!flag)
|
||||
break;
|
||||
if(judge(p[i],p[G[j][0]])){
|
||||
G[j].push_back(i);
|
||||
flag=0;
|
||||
}
|
||||
}
|
||||
if(!flag)
|
||||
continue;
|
||||
G[cnt].clear(); G[cnt++].push_back(i);
|
||||
}
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(int i=0;i<cnt;i++){
|
||||
sort(G[i].begin(),G[i].end(),cmp);
|
||||
memcpy(res,dp,sizeof(dp));
|
||||
memcpy(st,dp,sizeof(dp));
|
||||
int val=0,t=0;
|
||||
for(int j=0;j<G[i].size();j++){
|
||||
int id=G[i][j];
|
||||
t+=p[id].t; val+=p[id].val;
|
||||
if(t>T)
|
||||
break;
|
||||
for(int k=T;k>=t;k--)
|
||||
if(res[k]<=res[k-t]+val)
|
||||
res[k]=res[k-t]+val;
|
||||
for(int k=t;k<=T;k++)
|
||||
dp[k]=max(dp[k],res[k]);
|
||||
memcpy(res,st,sizeof(st));
|
||||
}
|
||||
}
|
||||
printf("Case %d: %d\n",++kase,dp[T]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
long long a;
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d",&a);
|
||||
double temp=ceil((1+sqrt(1+4*a))/2)-1;
|
||||
long long n=(long long)temp;
|
||||
long long res1=n+a;
|
||||
long long res2=n*(n+1)*(2*n+1)/3-3*(n+1)*n/2+n+(n+a-n*n+1)*n;
|
||||
printf("%I64d %I64d\n",res1,res2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int N=100050;
|
||||
int n,m,opt[20][N*2],x[N*2],cnt;
|
||||
struct node
|
||||
{
|
||||
int l,r;
|
||||
void read(){ scanf("%d%d",&l,&r); x[cnt++]=l; x[cnt++]=r; }
|
||||
void print(){ printf("%d %d\n",l,r); }
|
||||
bool operator <(const node tmp) const{ return l<tmp.l||(l==tmp.l&&r<tmp.r); }
|
||||
}no[N];
|
||||
inline int getid(int val,bool f)
|
||||
{
|
||||
if(!f) return lower_bound(x,x+cnt,val)-x;
|
||||
return upper_bound(x,x+cnt,val)-x-1;
|
||||
}
|
||||
int calc(int l,int r)
|
||||
{
|
||||
if(l>r) return 0;
|
||||
if(l==cnt||r==-1) return 0;
|
||||
int ret=0;
|
||||
for(int i=19;i>=0;i--){
|
||||
if(opt[i][l]<=r) {
|
||||
ret+=(1<<i);
|
||||
l=opt[i][l];
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)!=-1)
|
||||
{
|
||||
cnt=0;
|
||||
for(int i=0;i<n;i++){
|
||||
no[i].read();
|
||||
}
|
||||
sort(no,no+n);
|
||||
sort(x,x+cnt);
|
||||
cnt=unique(x,x+cnt)-x;
|
||||
for(int i=0;i<n;i++){
|
||||
no[i].l=getid(no[i].l,0);
|
||||
no[i].r=getid(no[i].r,1);
|
||||
}
|
||||
x[cnt]=cnt;
|
||||
int mn=cnt,r=n;
|
||||
for(int i=cnt-1;i>=0;i--)
|
||||
{
|
||||
while(r>0&&no[r-1].l>=i){
|
||||
r--;
|
||||
mn=min(mn,no[r].r);
|
||||
}
|
||||
opt[0][i]=mn;
|
||||
}
|
||||
for(int i=0;i<20;i++) opt[i][cnt]=cnt;
|
||||
for(int i=1;i<20;i++){
|
||||
for(int j=0;j<cnt;j++){
|
||||
opt[i][j]=opt[i-1][opt[i-1][j]];
|
||||
}
|
||||
}
|
||||
while(m--)
|
||||
{
|
||||
int l,r;
|
||||
scanf("%d%d",&l,&r);
|
||||
l=getid(l,0); r=getid(r,1);
|
||||
printf("%d\n",calc(l,r));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
#define Times 10
|
||||
typedef __int64 LL;
|
||||
map<LL,int>m;
|
||||
LL Random(LL n)
|
||||
{
|
||||
return ((double)rand()/RAND_MAX*n+0.5);
|
||||
}
|
||||
LL multi(LL a,LL b,LL mod)
|
||||
{
|
||||
LL ans=0;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
b--;
|
||||
ans=(ans+a)%mod;
|
||||
}
|
||||
else
|
||||
{
|
||||
b/=2;
|
||||
a=(a+a)%mod;
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL Pow(LL a,LL b,LL mod)
|
||||
{
|
||||
LL ans=1;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
b--;
|
||||
ans=multi(ans,a,mod);
|
||||
}
|
||||
else
|
||||
{
|
||||
b/=2;
|
||||
a=multi(a,a,mod);
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
bool witness(LL a,LL n)
|
||||
{
|
||||
LL d=n-1;
|
||||
while(!(d&1))
|
||||
d>>=1;
|
||||
LL t=Pow(a,d,n);
|
||||
while(d!=n-1 && t!=1 && t!=n-1)
|
||||
{
|
||||
t=multi(t,t,n);
|
||||
d<<=1;
|
||||
}
|
||||
return t==n-1 || d&1;
|
||||
}
|
||||
bool miller_rabin(LL n)
|
||||
{
|
||||
if(n==2)
|
||||
return true;
|
||||
if(n<2||!(n&1))
|
||||
return false;
|
||||
for(int i=1;i<=Times;i++)
|
||||
{
|
||||
LL a=Random(n-2)+1;
|
||||
if(!witness(a,n))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
LL gcd(LL a,LL b)
|
||||
{
|
||||
if(b==0)
|
||||
return a;
|
||||
return gcd(b,a%b);
|
||||
}
|
||||
LL pollard_rho(LL n,LL c)
|
||||
{
|
||||
LL x,y,d,i=1,k=2;
|
||||
x=Random(n-1)+1;
|
||||
y=x;
|
||||
while(1)
|
||||
{
|
||||
i++;
|
||||
x=(multi(x,x,n)+c)%n;
|
||||
d=gcd(y-x,n);
|
||||
if(1<d&&d<n)
|
||||
return d;
|
||||
if(y==x)
|
||||
return n;
|
||||
if(i==k)
|
||||
{
|
||||
y=x;
|
||||
k<<=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
void find(LL n,LL c)
|
||||
{
|
||||
if(n==1)
|
||||
return ;
|
||||
if(miller_rabin(n))
|
||||
{
|
||||
m[n]++;
|
||||
return ;
|
||||
}
|
||||
LL p=n;
|
||||
while(p>=n)
|
||||
p=pollard_rho(p,c--);
|
||||
find(p,c);
|
||||
find(n/p,c);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
LL n;
|
||||
cin>>n;
|
||||
m.clear();
|
||||
find(n,2013724);
|
||||
if(m.size()==1)
|
||||
cout<<1<<" "<<n/m.begin()->first<<endl;
|
||||
else
|
||||
{
|
||||
LL ans=0;
|
||||
map<LL,int>::iterator it=m.begin();
|
||||
for(;it!=m.end();it++)
|
||||
ans+=Pow(it->first,it->second,n);
|
||||
cout<<m.size()<<" "<<ans<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
const int MAXN=1100;
|
||||
int prime[MAXN+1];
|
||||
int getPrime()
|
||||
{
|
||||
memset(prime,0,sizeof(prime));
|
||||
for(int i=2;i<=MAXN;i++)
|
||||
{
|
||||
if(!prime[i]) prime[++prime[0]]=i;
|
||||
for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++)
|
||||
{
|
||||
prime[prime[j]*i]=1;
|
||||
if(i%prime[j]==0)break;
|
||||
}
|
||||
}
|
||||
return prime[0];
|
||||
}
|
||||
long long dp[MAXN][MAXN];
|
||||
long long DP(int n,int i)
|
||||
{
|
||||
if(dp[n][i]!=-1)return dp[n][i];
|
||||
if(prime[i]>n)
|
||||
{
|
||||
dp[n][i]=1;
|
||||
return dp[n][i];
|
||||
}
|
||||
int k=0;
|
||||
dp[n][i]=0;
|
||||
while(k<=n)
|
||||
{
|
||||
dp[n][i]+=DP(n-k,i+1);
|
||||
if(k==0)k=prime[i];
|
||||
else k*=prime[i];
|
||||
}
|
||||
return dp[n][i];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
getPrime();
|
||||
memset(dp,-1,sizeof(dp));
|
||||
int n;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
printf("%I64d\n",DP(n,1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
#define mod 1000000007
|
||||
int t;
|
||||
long long mod_pow(int a,int n,int p)
|
||||
{
|
||||
long long ret=1;
|
||||
long long A=a;
|
||||
while(n){
|
||||
if (n & 1)
|
||||
ret=(ret*A)%p;
|
||||
A=(A*A)%p;
|
||||
n>>=1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main(){
|
||||
scanf("%d",&t);
|
||||
while( t -- ){
|
||||
char str[808];
|
||||
scanf("%s",str);
|
||||
int len = strlen(str);
|
||||
int unknown = 0, r_num = 0;
|
||||
for(int i = 0; i < len; i ++){
|
||||
if(str[i] == '?') unknown ++;
|
||||
else if(str[i] == 'R') r_num ++;
|
||||
}
|
||||
long long unbea = (r_num == 0);
|
||||
for(int i = 0; i < len; i ++){
|
||||
if(str[i] == 'R' || str[i] == '?'){
|
||||
int x = (str[i] == 'R');
|
||||
unbea = (unbea + (x == r_num) ) % mod;
|
||||
for(int dis = 1; dis + i < len; dis += 2){
|
||||
int y = x;
|
||||
for(int sta = i + dis; sta < len; sta += dis){
|
||||
y += (str[sta] == 'R');
|
||||
if(str[sta] == 'G') break;
|
||||
unbea = (unbea + (y == r_num) )% mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",mod_pow(2,unknown,mod) - unbea);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include<queue>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int N=55555,K=5;
|
||||
const int inf=0x3f3f3f3f;
|
||||
#define sqr(x) (x)*(x)
|
||||
int k,n,idx;
|
||||
struct point
|
||||
{
|
||||
int x[K];
|
||||
bool operator < (const point &u) const
|
||||
{
|
||||
return x[idx]<u.x[idx];
|
||||
}
|
||||
}po[N];
|
||||
typedef pair<double,point>tp;
|
||||
priority_queue<tp>nq;
|
||||
struct kdTree
|
||||
{
|
||||
point pt[N<<2];
|
||||
int son[N<<2];
|
||||
void build(int l,int r,int rt=1,int dep=0)
|
||||
{
|
||||
if(l>r) return;
|
||||
son[rt]=r-l;
|
||||
son[rt*2]=son[rt*2+1]=-1;
|
||||
idx=dep%k;
|
||||
int mid=(l+r)/2;
|
||||
nth_element(po+l,po+mid,po+r+1);
|
||||
pt[rt]=po[mid];
|
||||
build(l,mid-1,rt*2,dep+1);
|
||||
build(mid+1,r,rt*2+1,dep+1);
|
||||
}
|
||||
void query(point p,int m,int rt=1,int dep=0)
|
||||
{
|
||||
if(son[rt]==-1) return;
|
||||
tp nd(0,pt[rt]);
|
||||
for(int i=0;i<k;i++) nd.first+=sqr(nd.second.x[i]-p.x[i]);
|
||||
int dim=dep%k,x=rt*2,y=rt*2+1,fg=0;
|
||||
if(p.x[dim]>=pt[rt].x[dim]) swap(x,y);
|
||||
if(~son[x]) query(p,m,x,dep+1);
|
||||
if(nq.size()<m) nq.push(nd),fg=1;
|
||||
else
|
||||
{
|
||||
if(nd.first<nq.top().first) nq.pop(),nq.push(nd);
|
||||
if(sqr(p.x[dim]-pt[rt].x[dim])<nq.top().first) fg=1;
|
||||
}
|
||||
if(~son[y]&&fg) query(p,m,y,dep+1);
|
||||
}
|
||||
}kd;
|
||||
void print(point &p)
|
||||
{
|
||||
for(int j=0;j<k;j++) printf("%d%c",p.x[j],j==k-1?'\n':' ');
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&k)!=EOF)
|
||||
{
|
||||
for(int i=0;i<n;i++) for(int j=0;j<k;j++) scanf("%d",&po[i].x[j]);
|
||||
kd.build(0,n-1);
|
||||
int t,m;
|
||||
for(scanf("%d",&t);t--;)
|
||||
{
|
||||
point ask;
|
||||
for(int j=0;j<k;j++) scanf("%d",&ask.x[j]);
|
||||
scanf("%d",&m); kd.query(ask,m);
|
||||
printf("the closest %d points are:\n", m);
|
||||
point pt[20];
|
||||
for(int j=0;!nq.empty();j++) pt[j]=nq.top().second,nq.pop();
|
||||
for(int j=m-1;j>=0;j--) print(pt[j]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int maxn = 100010;
|
||||
int n, m;
|
||||
struct Node {
|
||||
long long d, td;
|
||||
int timelabel;
|
||||
Node() {};
|
||||
Node(long long _d, long long _td, int t) {
|
||||
d = _d; td = _td; timelabel = t;
|
||||
}
|
||||
};
|
||||
vector<Node> bit[maxn];
|
||||
long long a[maxn], sum[maxn] = {0};
|
||||
inline int lowbit(int x)
|
||||
{
|
||||
return x & (-x);
|
||||
}
|
||||
inline void update(int x, long long w, int timelabel)
|
||||
{
|
||||
int size;
|
||||
long long tw = w * x;
|
||||
while (x <= n) {
|
||||
size = bit[x].size();
|
||||
bit[x].push_back(bit[x][size-1]);
|
||||
size++;
|
||||
bit[x][size-1].d += w;
|
||||
bit[x][size-1].td += tw;
|
||||
bit[x][size-1].timelabel = timelabel;
|
||||
x += lowbit(x);
|
||||
}
|
||||
}
|
||||
inline long long getsum(int x, int timelabel)
|
||||
{
|
||||
long long sd = 0, std = 0;
|
||||
int size, ox = x;
|
||||
while (x > 0) {
|
||||
size = bit[x].size();
|
||||
while (bit[x][size-1].timelabel > timelabel) {
|
||||
size--;
|
||||
}
|
||||
sd += bit[x][size-1].d;
|
||||
std += bit[x][size-1].td;
|
||||
x -= lowbit(x);
|
||||
}
|
||||
return (ox + 1) * sd - std;
|
||||
}
|
||||
inline long long getans(int x, int y, int timelabel)
|
||||
{
|
||||
return sum[y] - sum[x-1] + getsum(y, timelabel) - getsum(x - 1, timelabel);
|
||||
}
|
||||
inline void back(int timelabel)
|
||||
{
|
||||
int size;
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
size = bit[i].size();
|
||||
while (bit[i][size-1].timelabel > timelabel) {
|
||||
bit[i].pop_back();
|
||||
size--;
|
||||
}
|
||||
}
|
||||
}
|
||||
void build()
|
||||
{
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
bit[i].clear();
|
||||
bit[i].push_back(Node(0LL, 0LL, 0));
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas = 0;
|
||||
while (scanf("%d%d", &n, &m) != EOF) {
|
||||
if (cas++) printf("\n");
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
scanf("%lld\n", &a[i]);
|
||||
sum[i] = sum[i-1] + a[i];
|
||||
}
|
||||
char op[3];
|
||||
int x, y, z;
|
||||
int timelabel = 0;
|
||||
build();
|
||||
while (m--) {
|
||||
scanf("%s", op);
|
||||
if (op[0] == 'Q') {
|
||||
scanf("%d%d", &x, &y);
|
||||
printf("%lld\n", getans(x, y, timelabel));
|
||||
} else if (op[0] == 'C') {
|
||||
scanf("%d%d%d", &x, &y, &z);
|
||||
timelabel++;
|
||||
update(x, z, timelabel);
|
||||
update(y + 1, -z, timelabel);
|
||||
} else if (op[0] == 'H') {
|
||||
scanf("%d%d%d", &x, &y, &z);
|
||||
printf("%lld\n", getans(x, y, z));
|
||||
} else {
|
||||
scanf("%d", &x);
|
||||
timelabel = x;
|
||||
back(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include"cstdlib"
|
||||
#include"cstdio"
|
||||
#include"cstring"
|
||||
#include"cmath"
|
||||
#include"stack"
|
||||
#include"algorithm"
|
||||
#include"iostream"
|
||||
#define ll __int64
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(cin>>n)
|
||||
{
|
||||
int cnt=0;
|
||||
while(n)
|
||||
{
|
||||
if(n%2==1) cnt++;
|
||||
n/=2;
|
||||
}
|
||||
printf("%d\n",1<<cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int ans[10000][53];
|
||||
int main(){
|
||||
int T, op, left, right;
|
||||
scanf("%d", &T);
|
||||
for(int t=1; t<=T; t++){
|
||||
for(int i=1; i<=52; i++)
|
||||
scanf("%d", &ans[0][i]);
|
||||
scanf("%d %d %d", &op, &left, &right);
|
||||
int len = 1;
|
||||
while(1){
|
||||
int tag = 1;
|
||||
for(int i=left; i<=right; i++)
|
||||
ans[len][tag++] = ans[len-1][i];
|
||||
for(int i=1; i<left; i++)
|
||||
ans[len][tag++] = ans[len-1][i];
|
||||
for(int i=right+1; i<=52; i++)
|
||||
ans[len][tag++] = ans[len-1][i];
|
||||
bool flag = true;
|
||||
for(int i=1; i<=52; i++)
|
||||
if(ans[0][i] != ans[len][i]){
|
||||
flag = false;
|
||||
break;
|
||||
}
|
||||
if(flag){
|
||||
tag = op%len;
|
||||
printf("Case #%d:", t);
|
||||
for(int i=1; i<=52; i++)
|
||||
printf(" %d", ans[tag][i]);
|
||||
printf("\n");
|
||||
break;
|
||||
}
|
||||
len++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef struct
|
||||
{
|
||||
int l,r,sum;
|
||||
int lsum,rsum,midsum;
|
||||
}Tree;
|
||||
Tree tree[500005];
|
||||
int a[100005];
|
||||
int c[2000][2000];
|
||||
int ans,rans;
|
||||
int Count(int t)
|
||||
{
|
||||
if (t==0) return 0;
|
||||
int s=0;
|
||||
while(t)
|
||||
{
|
||||
s+=t%10;
|
||||
t/=10;
|
||||
}
|
||||
s%=9;
|
||||
if (s==0) return 9;
|
||||
return s;
|
||||
}
|
||||
int Pre()
|
||||
{
|
||||
int i,j,x,y;
|
||||
for (i=0;i<1024;i++)
|
||||
{
|
||||
for (j=i;j<1024;j++)
|
||||
{
|
||||
c[i][j]=0;
|
||||
for (x=0;x<10;x++)
|
||||
{
|
||||
if ((i & (1<<x))==0) continue;
|
||||
for (y=0;y<10;y++)
|
||||
{
|
||||
if ((j & (1<<y))==0) continue;
|
||||
c[i][j]=(c[i][j]|(1<<Count(x+y)));
|
||||
}
|
||||
}
|
||||
c[j][i]=c[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
void Build(int t,int l,int r)
|
||||
{
|
||||
tree[t].l=l;
|
||||
tree[t].r=r;
|
||||
if (l==r)
|
||||
{
|
||||
tree[t].sum=a[l];
|
||||
tree[t].lsum=(1<<a[l]);
|
||||
tree[t].rsum=(1<<a[l]);
|
||||
tree[t].midsum=(1<<a[l]);
|
||||
return;
|
||||
}
|
||||
int mid=(l+r)/2;
|
||||
Build(2*t+1,l,mid);
|
||||
Build(2*t+2,mid+1,r);
|
||||
tree[t].sum=Count(tree[2*t+1].sum+tree[2*t+2].sum);
|
||||
tree[t].lsum=(tree[2*t+1].lsum | c[1<<tree[2*t+1].sum][tree[2*t+2].lsum]);
|
||||
tree[t].rsum=(tree[2*t+2].rsum | c[tree[2*t+1].rsum][1<<tree[2*t+2].sum]);
|
||||
tree[t].midsum=(tree[2*t+1].midsum | tree[2*t+2].midsum | c[tree[2*t+1].rsum][tree[2*t+2].lsum]);
|
||||
}
|
||||
void Query(int t,int x,int y)
|
||||
{
|
||||
int l,r;
|
||||
l=tree[t].l;
|
||||
r=tree[t].r;
|
||||
if (l==x && r==y)
|
||||
{
|
||||
ans=(ans | tree[t].midsum | c[rans][tree[t].lsum]);
|
||||
rans=(c[rans][1<<tree[t].sum] | tree[t].rsum);
|
||||
return;
|
||||
}
|
||||
int mid=(l+r)/2;
|
||||
if (mid>=x) Query(2*t+1,x,min(y,mid));
|
||||
if (mid<y) Query(2*t+2,max(x,mid+1),y);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,i,j,n,x,y,m,s,cnt=1;
|
||||
Pre();
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for (i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
a[i]=Count(a[i]);
|
||||
}
|
||||
Build(0,0,n-1);
|
||||
scanf("%d",&m);
|
||||
printf("Case #%d:\n",cnt++);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
ans=rans=0;
|
||||
Query(0,x-1,y-1);
|
||||
s=0;
|
||||
for (i=9;i>=0;i--)
|
||||
{
|
||||
if (ans>=(1<<i))
|
||||
{
|
||||
ans-=(1<<i);
|
||||
if (s==0) printf("%d",i);
|
||||
else printf(" %d",i);
|
||||
s++;
|
||||
if (s==5) break;
|
||||
}
|
||||
}
|
||||
for (i=s;i<5;i++)
|
||||
{
|
||||
printf(" -1");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
if (T>0) printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<bitset>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
#include<deque>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int N = 20;
|
||||
ll dp[N][10][1<<10][11];
|
||||
int has[1<<10];
|
||||
int ne[1<<10][10];
|
||||
int bit[N],K;
|
||||
int go(int mask,int number){
|
||||
int pos = -1;
|
||||
for(int i = number;i <=9;i++)
|
||||
if(mask & (1<<i)){
|
||||
pos = i;
|
||||
break;
|
||||
}
|
||||
if(pos == -1)mask |= 1<<number;
|
||||
else{
|
||||
mask ^= 1<<pos;
|
||||
mask |= 1<<number;
|
||||
}
|
||||
return mask;
|
||||
}
|
||||
void init(){
|
||||
memset(dp,-1,sizeof(dp));
|
||||
for(int i=0;i<1<<10;i++){
|
||||
has[i] = 0;
|
||||
for(int j=0;j<10;j++)
|
||||
if(i&(1<<j))has[i]++;
|
||||
}
|
||||
for(int i = 0;i < 1<<10;i++)
|
||||
for(int j = 0;j < 10;j++)
|
||||
ne[i][j] = go(i,j);
|
||||
for(int i = 0;i < 15;i++){
|
||||
for(int j=0;j<10;j++){
|
||||
}
|
||||
}
|
||||
}
|
||||
ll dfs(int pos,int number,int mask,bool isZero,bool flag){
|
||||
if(pos == 0)return has[mask] == K;
|
||||
if(flag && ~dp[pos][number][mask][K])return dp[pos][number][mask][K];
|
||||
ll ans = 0;
|
||||
int u = flag ? 9:bit[pos];
|
||||
for(int d = 0;d <= u;d++){
|
||||
if(isZero && d == 0)ans += dfs(pos-1,d,0,1,flag || d < u);
|
||||
else{
|
||||
ans += dfs(pos-1,d,ne[mask][d],0,flag || d < u);
|
||||
}
|
||||
}
|
||||
if(flag)dp[pos][number][mask][K] = ans ;
|
||||
return ans;
|
||||
}
|
||||
ll solve(ll n){
|
||||
int len = 0;
|
||||
while(n){
|
||||
bit[++len] = n % 10;
|
||||
n /= 10;
|
||||
}
|
||||
return dfs(len,0,0,1,0);
|
||||
}
|
||||
int main(){
|
||||
init();
|
||||
ll L,R;
|
||||
int T;cin >> T;
|
||||
for(int cas = 1;cas <= T;cas++){
|
||||
cin >> L >> R >> K;
|
||||
cout<<"Case #"<<cas<<": "<<solve(R) - solve(L - 1)<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
struct point{
|
||||
int x, y;
|
||||
point() {}
|
||||
point(int a, int b) : x(a), y(b){}
|
||||
void input(){
|
||||
scanf("%d%d", &x, &y);
|
||||
}
|
||||
friend point operator - (const point &a, const point &b){
|
||||
return point(a.x - b.x, a.y - b.y);
|
||||
}
|
||||
friend bool operator < (const point &a, const point &b){
|
||||
return a.x < b.x;
|
||||
}
|
||||
};
|
||||
const int maxn = 200 + 10, maxm = 500 + 10;
|
||||
point po[maxn], mi[maxm];
|
||||
int det(point a, point b){
|
||||
return a.x * b.y - a.y * b.x;
|
||||
}
|
||||
int num[maxn][maxn];
|
||||
int n, m, cs;
|
||||
void init(point a, point b, int &cnt){
|
||||
int x1 = a.x, x2 = b.x;
|
||||
for (int i = 0; i < m; i++)
|
||||
if (mi[i].x >= x1 && mi[i].x < x2)
|
||||
if (det(mi[i] - a, b - a) > 0)
|
||||
cnt += 1;
|
||||
}
|
||||
int main(){
|
||||
scanf("%d", &cs);
|
||||
for (int kase = 1; kase <= cs; ++kase){
|
||||
scanf("%d%d", &n, &m);
|
||||
for (int i = 0; i < n; i++)
|
||||
po[i].input();
|
||||
for (int i = 0; i < m; i++)
|
||||
mi[i].input();
|
||||
sort(po, po + n);
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = i + 1; j < n; j++)
|
||||
init(po[i], po[j], num[i][j] = 0);
|
||||
printf("Case #%d: ", kase);
|
||||
double ans = -1;
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = i + 1; j < n; j++)
|
||||
for (int k = j + 1; k < n; k++){
|
||||
int cnt = num[i][k] - num[i][j] - num[j][k];
|
||||
if (!cnt) continue;
|
||||
double area = det(po[j] - po[i], po[k] - po[i]) / 2.0;
|
||||
double tmp = area / (double)cnt;
|
||||
if (ans == -1 || ans > tmp) ans = tmp;
|
||||
}
|
||||
if (ans == -1) puts("-1");
|
||||
else printf("%.6lf\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<bitset>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
#include<deque>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int C = 5005;
|
||||
const int N = 2005;
|
||||
const int M = 1005;
|
||||
int cnt[N];
|
||||
int vis[C];
|
||||
int dp[C][2];
|
||||
int c, n, k, m;
|
||||
vector<int>v[N];
|
||||
struct city
|
||||
{
|
||||
int x, y;
|
||||
bool operator<(const city &a) const
|
||||
{
|
||||
return x<a.x;
|
||||
}
|
||||
}ct[C];
|
||||
int min(int x, int y)
|
||||
{
|
||||
if(x==-1) return y;
|
||||
return x<y?x:y;
|
||||
}
|
||||
void dfs(int s)
|
||||
{
|
||||
vis[s] = 1;
|
||||
dp[s][1] = 1;
|
||||
dp[s][0] = 0;
|
||||
for(int i=0; i<v[s].size(); i++)
|
||||
{
|
||||
int ss = v[s][i];
|
||||
if(vis[ss]==1 || cnt[ss]==0) continue;
|
||||
dfs(ss);
|
||||
dp[s][1] += dp[ss][0];
|
||||
dp[s][0] += max(dp[ss][1], dp[ss][0]);
|
||||
}
|
||||
}
|
||||
bool ok(int l, int r)
|
||||
{
|
||||
int res = 0;
|
||||
memset(vis, 0, sizeof(vis));
|
||||
for(int i = l; i<=r; i++)
|
||||
if(vis[ ct[i].y ]==0)
|
||||
{
|
||||
dfs( ct[i].y );
|
||||
res += max( dp[ ct[i].y ][0], dp[ ct[i].y ][1] );
|
||||
}
|
||||
if(res>=k) return true;
|
||||
else return false;
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
int kk, l, r;
|
||||
kk = l = r = 1;
|
||||
cnt[ ct[1].y ]++;
|
||||
int ans = -1;
|
||||
while(r<=c)
|
||||
{
|
||||
if(kk>=k && ok(l, r))
|
||||
{
|
||||
ans = min(ans, ct[r].x - ct[l].x);
|
||||
cnt[ ct[l].y ]--;
|
||||
if( cnt[ ct[l].y ]==0 ) kk--;
|
||||
l++;
|
||||
}
|
||||
else
|
||||
{
|
||||
r++;
|
||||
cnt[ ct[r].y ]++;
|
||||
if( cnt[ ct[r].y ]==1 ) kk++;
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t, tt=0, i, x, y;
|
||||
scanf("%d", &t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d%d%d", &c, &n, &k, &m);
|
||||
for(i=1; i<=n; i++) v[i].clear();
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
memset(vis, 0, sizeof(vis));
|
||||
for(i=1; i<=c; i++) scanf("%d%d", &ct[i].x, &ct[i].y);
|
||||
sort(ct+1, ct+1+c);
|
||||
for(i=1; i<=m; i++)
|
||||
{
|
||||
scanf("%d%d", &x, &y);
|
||||
v[x].push_back(y);
|
||||
v[y].push_back(x);
|
||||
}
|
||||
printf("Case #%d: %d\n", ++tt, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int N = 10e4+1;
|
||||
const float eps = 1e-2;
|
||||
struct po
|
||||
{
|
||||
double x;
|
||||
double w;
|
||||
} point[N];
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
for(int cases = 1; cases<=t; cases++)
|
||||
{
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
for(int i=1; i<=n; i++)
|
||||
scanf("%lf %lf",&point[i].x,&point[i].w);
|
||||
double low = point[1].x;
|
||||
double high = point[n].x;
|
||||
double sum1 = 10;
|
||||
double sum2 = 0;
|
||||
while(fabs(sum1-sum2)>eps)
|
||||
{
|
||||
double mid1 = low + (high-low)/3;
|
||||
double mid2 = high - (high-low)/3;
|
||||
sum1 = sum2 = 0;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
sum1 += pow((fabs(point[i].x - mid1)),3)*point[i].w;
|
||||
sum2 += pow((fabs(point[i].x - mid2)),3)*point[i].w;
|
||||
}
|
||||
if(sum1<sum2)
|
||||
high = mid2;
|
||||
else if(sum1>sum2)
|
||||
low = mid1;
|
||||
else if(sum1==sum2)
|
||||
low = high;
|
||||
}
|
||||
printf("Case #%d: %.0lf\n",cases,sum1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#define MOD 1000000007
|
||||
#define N 2010
|
||||
using namespace std;
|
||||
int n,ans;
|
||||
int a[N],w[N];
|
||||
int f[N][N];
|
||||
int fac[N];
|
||||
void init(){
|
||||
fac[0]=1;
|
||||
int i,j;
|
||||
for (i=1;i<=n;i++)
|
||||
fac[i]=(1ll*fac[i-1]*i)%MOD;
|
||||
for (i=0;i<=n;i++) f[1][i]=n-i;
|
||||
for (i=1;i<=n;i++){
|
||||
for (j=0;j<w[i];j++) f[i+1][j]=f[i][j]-1;
|
||||
for (j=w[i];j<=n;j++) f[i+1][j]=f[i][j];
|
||||
}
|
||||
}
|
||||
int dfs(int k){
|
||||
if (k==n) return 0;
|
||||
int tp=(1ll*fac[n-k]*f[k][w[k]])%MOD;
|
||||
int tp1=dfs(k+1);
|
||||
if (w[k]>=a[k]) ans=(1ll*ans+tp1)%MOD;
|
||||
return (1ll*tp1+tp)%MOD;
|
||||
}
|
||||
void work(){
|
||||
int i,j,k;
|
||||
for (i=1;i<=n;i++){
|
||||
if (a[i]>w[i]) ans=(1ll*ans+1ll*f[i][a[i]-1]*fac[n-i])%MOD;
|
||||
else ans=(1ll*ans+1ll*f[i][w[i]]*fac[n-i])%MOD;
|
||||
for (j=i+1;j<=n;j++){
|
||||
k=f[i][w[i]]*f[i][a[j]-1]-min(f[i][w[i]],f[i][a[j]-1]);
|
||||
ans=(1ll*ans+1ll*k*fac[n-i-1])%MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int test;
|
||||
scanf("%d",&test);
|
||||
for (int cas=1;cas<=test;cas++){
|
||||
scanf("%d",&n);
|
||||
for (int i=1;i<=n;i++)
|
||||
scanf("%d",&w[i]);
|
||||
for (int i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
ans=0;
|
||||
init();
|
||||
work();
|
||||
dfs(1);
|
||||
printf("Case #%d: %d\n",cas,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include<iostream>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
int t;
|
||||
string a,b;
|
||||
int main()
|
||||
{
|
||||
cin>>t;
|
||||
for(int cas=1;cas<=t;cas++){
|
||||
cin>>a>>b;
|
||||
int len=a.length();
|
||||
cout<<"Case #"<<cas<<": ";
|
||||
if(len>2){
|
||||
int n=0,m=0;
|
||||
for(int i=0;i<len;i++){
|
||||
n+=a[i];
|
||||
m+=b[i];
|
||||
}
|
||||
if((n&1)==(m&1)) cout<<"YES"<<endl;
|
||||
else cout<<"NO"<<endl;
|
||||
}
|
||||
else{
|
||||
if(((a[0]-b[0]+26)%26)==((a[1]-b[1]+26)%26)&&(a[0]-b[0])%2==0||((a[0]-b[1]+26)%26)==((a[1]-b[0]+26)%26)&&(a[1]-b[0]+1)%2==0) cout<<"YES"<<endl;
|
||||
else cout<<"NO"<<endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,155 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#include <map>
|
||||
#pragma comment(linker, "/STACK:102400000,102400000")
|
||||
using namespace std;
|
||||
#define print(x) cout<<x<<endl
|
||||
#define input(x) cin>>x
|
||||
#define SIZE 100100
|
||||
struct BIT
|
||||
{
|
||||
int baum[SIZE];
|
||||
void init()
|
||||
{
|
||||
memset(baum,0,sizeof(baum));
|
||||
}
|
||||
inline int lowbit(int x)
|
||||
{
|
||||
return x&(-x);
|
||||
}
|
||||
void add(int x,int val)
|
||||
{
|
||||
while(x<SIZE)
|
||||
{
|
||||
baum[x]+=val;
|
||||
x+=lowbit(x);
|
||||
}
|
||||
}
|
||||
int sum(int x)
|
||||
{
|
||||
int res=0;
|
||||
while(x>0)
|
||||
{
|
||||
res+=baum[x];
|
||||
x-=lowbit(x);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int sum(int l,int r)
|
||||
{
|
||||
return sum(r)-sum(l-1);
|
||||
}
|
||||
};
|
||||
struct query
|
||||
{
|
||||
int l,r,id;
|
||||
query(){}
|
||||
query(int il,int ir,int iid)
|
||||
{
|
||||
l=il;r=ir;id=iid;
|
||||
}
|
||||
friend bool operator < (const query& a,const query& b)
|
||||
{
|
||||
return a.r<b.r;
|
||||
}
|
||||
};
|
||||
int n,k,q;
|
||||
int w[SIZE];
|
||||
vector<int> pl[SIZE];
|
||||
vector<int> g[SIZE];
|
||||
int lson[SIZE],rson[SIZE],val[SIZE];
|
||||
int cnt,ind;
|
||||
void dfs(int now,int father)
|
||||
{
|
||||
lson[now]=rson[now]=++ind;
|
||||
val[now]=w[now];
|
||||
for(int i=0;i<(int)g[now].size();i++)
|
||||
{
|
||||
int next=g[now][i];
|
||||
if(next!=father)
|
||||
{
|
||||
dfs(next,now);
|
||||
rson[now]=rson[next];
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,a,b;
|
||||
BIT bit;
|
||||
query ask[SIZE];
|
||||
int ans[SIZE];
|
||||
map<int,int> mp;
|
||||
input(T);
|
||||
int cas=1;
|
||||
while(T--)
|
||||
{
|
||||
bit.init();
|
||||
cnt=ind=0;
|
||||
mp.clear();
|
||||
memset(ans,0,sizeof(ans));
|
||||
for(int i=0;i<SIZE;i++) g[i].clear();
|
||||
scanf("%d%d",&n,&k);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&w[i]);
|
||||
if(!mp[w[i]])
|
||||
{
|
||||
mp[w[i]]=++cnt;
|
||||
pl[cnt].clear();
|
||||
}
|
||||
w[i]=mp[w[i]];
|
||||
}
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
g[a].push_back(b);
|
||||
g[b].push_back(a);
|
||||
}
|
||||
dfs(1,-1);
|
||||
scanf("%d",&q);
|
||||
for(int i=0;i<q;i++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
ask[i]=query(lson[a],rson[a],i);
|
||||
}
|
||||
sort(ask,ask+q);
|
||||
int ptr=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
int v=val[i];
|
||||
pl[v].push_back(i);
|
||||
int sz=pl[v].size();
|
||||
if(sz>=k)
|
||||
{
|
||||
if(sz==k)
|
||||
{
|
||||
bit.add(pl[v][sz-k],1);
|
||||
}
|
||||
if(sz>k)
|
||||
{
|
||||
bit.add(pl[v][sz-k-1],-2);
|
||||
bit.add(pl[v][sz-k],1);
|
||||
}
|
||||
}
|
||||
while(ask[ptr].r==i)
|
||||
{
|
||||
int id=ask[ptr].id;
|
||||
ans[id]=bit.sum(ask[ptr].l,ask[ptr].r);
|
||||
ptr++;
|
||||
}
|
||||
}
|
||||
printf("Case #%d:\n",cas++);
|
||||
for(int i=0;i<q;i++)
|
||||
{
|
||||
printf("%d\n",ans[i]);
|
||||
}
|
||||
if(T) puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#define inf 0x3f3f3f3f
|
||||
#define Inf 0x3FFFFFFFFFFFFFFFLL
|
||||
#define eps 1e-9
|
||||
#define pi acos(-1.0)
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn=365;
|
||||
const int mod=1000000000+7;
|
||||
ll dp[maxn][maxn],C[maxn][maxn];
|
||||
void Init()
|
||||
{
|
||||
memset(C,0,sizeof(C));
|
||||
C[0][0]=1;
|
||||
for(int i=1;i<maxn;++i)
|
||||
{
|
||||
C[i][0]=1;
|
||||
for(int j=1;j<=i;++j)
|
||||
{
|
||||
C[i][j]=C[i-1][j-1]+C[i-1][j];
|
||||
if(C[i][j]>=mod) C[i][j]-=mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
ll f(int n,int d)
|
||||
{
|
||||
if(n==1&&d>=1) return 1;
|
||||
if(n==1||d==0) return 0;
|
||||
if(dp[n][d]!=-1) return dp[n][d];
|
||||
ll &ans=dp[n][d];
|
||||
ans=0;
|
||||
ans=(ans+f(n-1,d-1)*n*2)%mod;
|
||||
for(int k=1;k<=n-2;++k)
|
||||
ans=(ans+(f(k,d-1)*f(n-k-1,d-1)%mod*C[n-2][k]%mod)*n)%mod;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Init();
|
||||
memset(dp,0xff,sizeof(dp));
|
||||
int t,tcase=0,n,d;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&d);
|
||||
ll ans=f(n,d)-f(n,d-1);
|
||||
ans=(ans+mod)%mod;
|
||||
printf("Case #%d: %I64d\n",++tcase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long lld;
|
||||
const int mn=3333;
|
||||
const int mm=33333;
|
||||
const lld oo=1e15;
|
||||
int reach[mm], ne[mm], flow[mm], ch[mm];
|
||||
lld head[mn], que[mn], dis[mn][4], cnt[mn][4], inque[mn];
|
||||
int n, edge;
|
||||
void addedge(int u, int v, int c1, int c2, char c)
|
||||
{
|
||||
ch[edge]=c, reach[edge]=v, flow[edge]=c1, ne[edge]=head[u], head[u]=edge++;
|
||||
ch[edge]=c, reach[edge]=u, flow[edge]=c2, ne[edge]=head[v], head[v]=edge++;
|
||||
}
|
||||
int find(char c)
|
||||
{
|
||||
if(c=='L') return 0;
|
||||
else if(c=='O') return 1;
|
||||
else if(c=='V') return 2;
|
||||
else return 3;
|
||||
}
|
||||
bool spfa()
|
||||
{
|
||||
int l=0, h=0;
|
||||
memset(inque,0,sizeof(inque));
|
||||
for(int i=1; i<=n; i++)
|
||||
for(int j=0; j<4; j++) dis[i][j]=oo, cnt[i][j]=0;
|
||||
inque[1]=1;
|
||||
dis[1][0]=0;
|
||||
que[l++]=1;
|
||||
while(l!=h)
|
||||
{
|
||||
int u=que[h++];
|
||||
if(h==mn) h=0;
|
||||
inque[u]=0;
|
||||
for(int i=head[u]; i>=0; i=ne[i])
|
||||
{
|
||||
int s=find(ch[i]), v=reach[i], val=flow[i];
|
||||
if(dis[v][(s+1)%4]>=dis[u][s]+val)
|
||||
{
|
||||
if(dis[v][(s+1)%4]==dis[u][s]+val)
|
||||
{
|
||||
if(cnt[u][s]+1>cnt[v][(s+1)%4]) cnt[v][(s+1)%4]=cnt[u][s]+1;
|
||||
else continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
dis[v][(s+1)%4]=dis[u][s]+val;
|
||||
cnt[v][(s+1)%4]=cnt[u][s]+1;
|
||||
}
|
||||
if(!inque[v])
|
||||
{
|
||||
inque[v]=1;
|
||||
que[l++]=v;
|
||||
if(l==mn) l=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(dis[n][0]==oo||!cnt[n][0]) return false;
|
||||
else return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m, T, tcase=0;
|
||||
cin >> T;
|
||||
while(T--)
|
||||
{
|
||||
cin >> n >> m;
|
||||
edge=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
int mp[4]={0,0,0,0}, ct=0;
|
||||
while(m--)
|
||||
{
|
||||
int u, v, val, se;
|
||||
char sh[3];
|
||||
scanf("%d%d%d%s",&u,&v,&val,sh);
|
||||
addedge(u,v,val,val,sh[0]);
|
||||
if(n==1&&u==1&&v==1)
|
||||
{
|
||||
se=find(sh[0]);
|
||||
if(!mp[se]) ct++, mp[se]=val;
|
||||
else mp[se]=min(mp[se],val);
|
||||
}
|
||||
}
|
||||
if(ct==4)
|
||||
{
|
||||
lld sum=mp[0]+mp[1]+mp[2]+mp[3];
|
||||
printf("Case %d: Cute Sangsang, Binbin will come with a donkey after travelling %I64d meters and finding %d LOVE strings at last.\n",++tcase,sum,ct/4);
|
||||
continue;
|
||||
}
|
||||
bool ok=spfa();
|
||||
if(!ok) printf("Case %d: Binbin you disappoint Sangsang again, damn it!\n",++tcase);
|
||||
else printf("Case %d: Cute Sangsang, Binbin will come with a donkey after travelling %I64d meters and finding %d LOVE strings at last.\n",++tcase,dis[n][0],cnt[n][0]/4);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
int main()
|
||||
{
|
||||
srand(1121139700);
|
||||
int caseNumber;
|
||||
scanf("%d", &caseNumber);
|
||||
while(caseNumber --)
|
||||
if(rand() & 1) printf("alive!\n");
|
||||
else printf("dead!\n");
|
||||
}
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
const int Ni = 1005;
|
||||
const int inf=1<<27;
|
||||
struct node{
|
||||
int x,w;
|
||||
bool operator < (const node &a) const
|
||||
{
|
||||
return x<a.x;
|
||||
}
|
||||
}arr[52][Ni];
|
||||
struct qnode{
|
||||
int val,x;
|
||||
bool operator < (const qnode &a) const
|
||||
{
|
||||
if(val>a.val) return 1;
|
||||
if(val==a.val&&x>a.x) return 1;
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
int dp[52][Ni];
|
||||
int n,m;
|
||||
inline void cInit()
|
||||
{
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&arr[i][j].x);
|
||||
}
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&arr[i][j].w);
|
||||
}
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
sort(arr[i],arr[i]+m);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cs,x,i,j,ans;
|
||||
cin>>cs;
|
||||
while(cs--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&x);
|
||||
cInit();
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
dp[0][j]=x-arr[0][j].x;
|
||||
if(dp[0][j]<0) dp[0][j]=-dp[0][j];
|
||||
dp[0][j]+=arr[0][j].w;
|
||||
}
|
||||
for(i=1;i<n;i++)
|
||||
{
|
||||
priority_queue<qnode> ql,qr;
|
||||
qnode qn;
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
qn.val=dp[i-1][j]+arr[i-1][j].x;
|
||||
qn.x=arr[i-1][j].x;
|
||||
qr.push(qn);
|
||||
}
|
||||
int k=0;
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
dp[i][j]=inf;
|
||||
while(k<m&&arr[i-1][k].x<=arr[i][j].x)
|
||||
{
|
||||
qn.val=dp[i-1][k]-arr[i-1][k].x;
|
||||
qn.x=arr[i-1][k].x;
|
||||
ql.push(qn);
|
||||
k++;
|
||||
}
|
||||
if(!ql.empty())
|
||||
{
|
||||
qn=ql.top();
|
||||
dp[i][j]=min(dp[i][j],qn.val+arr[i][j].x+arr[i][j].w);
|
||||
}
|
||||
if(!qr.empty())
|
||||
{
|
||||
qn=qr.top();
|
||||
while(!qr.empty()&&qn.x<arr[i][j].x)
|
||||
{
|
||||
qr.pop();
|
||||
qn=qr.top();
|
||||
}
|
||||
if(qn.x>=arr[i][j].x)
|
||||
dp[i][j]=min(dp[i][j],qn.val-arr[i][j].x+arr[i][j].w);
|
||||
}
|
||||
}
|
||||
}
|
||||
ans=inf;
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
if(ans>dp[n-1][i])
|
||||
ans=dp[n-1][i];
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#define inf 1<<29
|
||||
#define LL long long
|
||||
#define MOD 1000000007
|
||||
using namespace std;
|
||||
int dp[41][41][5][5][5][5][2];
|
||||
int get_dp(int x,int y,int l,int r,int u,int d,int k){
|
||||
if(dp[x][y][l][r][u][d][k]!=-1)
|
||||
return dp[x][y][l][r][u][d][k];
|
||||
dp[x][y][l][r][u][d][k]=0;
|
||||
if((x==1&&k==0)||(y==1&&k)){
|
||||
for(int i=1;i<5;i++)
|
||||
if(i!=l&&i!=r&&i!=u&&i!=d)
|
||||
dp[x][y][l][r][u][d][k]++;
|
||||
return dp[x][y][l][r][u][d][k];
|
||||
}
|
||||
dp[x][y][l][r][u][d][k]=0;
|
||||
if(!k){
|
||||
for(int i=1;i<x;i++)
|
||||
for(int j=1;j<5;j++){
|
||||
if(j!=u&&j!=l&&j!=r)
|
||||
dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(x-i,y,l,r,j,d,1))%MOD;
|
||||
if(j!=d&&j!=l&&j!=r)
|
||||
dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(i,y,l,r,u,j,1))%MOD;
|
||||
}
|
||||
int t=0;
|
||||
for(int i=1;i<=4;i++)
|
||||
if(i!=u&&i!=l&&i!=r)
|
||||
for(int j=1;j<=4;j++)
|
||||
if(j!=d&&j!=l&&j!=r&&j!=i)
|
||||
t++;
|
||||
dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+MOD-t*(x-1))%MOD;
|
||||
for(int i=1;i<5;i++)
|
||||
if(i!=l&&i!=r&&i!=u&&i!=d)
|
||||
dp[x][y][l][r][u][d][k]++;
|
||||
}
|
||||
else{
|
||||
for(int i=1;i<y;i++)
|
||||
for(int j=1;j<5;j++){
|
||||
if(j!=l&&j!=d&&j!=u)
|
||||
dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(x,y-i,j,r,u,d,0))%MOD;
|
||||
if(j!=r&&j!=d&&j!=u)
|
||||
dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(x,i,l,j,u,d,0))%MOD;
|
||||
}
|
||||
int t=0;
|
||||
for(int i=1;i<=4;i++)
|
||||
if(i!=l&&i!=u&&i!=d)
|
||||
for(int j=1;j<=4;j++)
|
||||
if(j!=r&&j!=u&&j!=d&&j!=i)
|
||||
t++;
|
||||
dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+MOD-t*(y-1))%MOD;
|
||||
for(int i=1;i<5;i++)
|
||||
if(i!=l&&i!=r&&i!=u&&i!=d)
|
||||
dp[x][y][l][r][u][d][k]++;
|
||||
}
|
||||
return dp[x][y][l][r][u][d][k]%MOD;
|
||||
}
|
||||
int main(){
|
||||
memset(dp,-1,sizeof(dp));
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
int x,y;
|
||||
scanf("%d%d",&x,&y);
|
||||
printf("%d\n",get_dp(x,y,0,0,0,0,0));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
int ans[5][5]={{2,3,1,1},{1,2,3,1},{1,1,2,3},{3,1,1,2}};
|
||||
int matrix[5][5];
|
||||
int a[5][5];
|
||||
void multi()
|
||||
{
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
for(int j=0;j<4;j++)
|
||||
{
|
||||
for(int k=0;k<4;k++)
|
||||
{
|
||||
int t=matrix[k][j];
|
||||
t<<=1;
|
||||
if(t>0xFF)//225
|
||||
t=(t^0x1B)%(0xFF+1);
|
||||
if(ans[i][k]==1)
|
||||
{
|
||||
a[i][j]^=matrix[k][j];
|
||||
}
|
||||
else if(ans[i][k]==2)
|
||||
{
|
||||
a[i][j]^=t;
|
||||
}
|
||||
else if(ans[i][k]==3)
|
||||
{
|
||||
t^=matrix[k][j];
|
||||
a[i][j]^=t;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas;
|
||||
scanf("%d",&cas);
|
||||
while(cas--)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
for(int i=0;i<4;i++)
|
||||
for(int j=0;j<4;j++)
|
||||
scanf("%X",&matrix[i][j]);
|
||||
multi();
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
for(int j=0;j<4;j++)
|
||||
{
|
||||
if(j!=0)
|
||||
cout<<' ';
|
||||
printf("%02X",a[i][j]);
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
if(cas != 0)
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#define LL long long
|
||||
#define MOD 100000007
|
||||
using namespace std;
|
||||
class Point
|
||||
{
|
||||
public:
|
||||
int x,y;
|
||||
bool operator == (const Point &tmp) const{
|
||||
return (x==tmp.x && y==tmp.y);
|
||||
}
|
||||
}p[2024];
|
||||
int midx,midy;
|
||||
bool cmp(const Point &a,const Point &b){
|
||||
if(a.x != b.x)
|
||||
return a.x < b.x;
|
||||
return a.y < b.y;
|
||||
}
|
||||
void Solve1( int x, int y , int cnt )
|
||||
{
|
||||
if( x > midx)
|
||||
{
|
||||
x = (midx<<1) - x;
|
||||
}
|
||||
if( y > midy ) y = (midy<<1) - y;
|
||||
if( x > y ) swap( x ,y );
|
||||
p[cnt].x = x; p[cnt].y = y;
|
||||
}
|
||||
void Solve2( int x, int y , int cnt )
|
||||
{
|
||||
if( x > midx )
|
||||
{
|
||||
int d = x - midx - 1;
|
||||
x = midx - d;
|
||||
}
|
||||
if( y > midy )
|
||||
{
|
||||
int d = y - midy - 1;
|
||||
y = midy - d;
|
||||
}
|
||||
if( x > y ) swap( x , y );
|
||||
p[cnt].x = x ; p[cnt].y = y;
|
||||
}
|
||||
LL Pow( LL k , LL a )
|
||||
{
|
||||
LL ans = 1;
|
||||
while( k )
|
||||
{
|
||||
if( k &1 ) ans = (ans*a)%MOD;
|
||||
a = (a*a)%MOD;
|
||||
k >>= 1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main( )
|
||||
{
|
||||
int n,m,k,x,y;
|
||||
while( scanf( "%d %d %d",&n,&m,&k )==3 )
|
||||
{
|
||||
midx = (n+1) /2;midy = midx;
|
||||
for( int i = 0; i < m ; i ++ )
|
||||
{
|
||||
scanf( "%d %d",&x,&y );
|
||||
x += 1 ; y += 1;
|
||||
if( n & 1 ) Solve1( x ,y , i );
|
||||
else Solve2( x , y , i );
|
||||
}
|
||||
LL L = ( n + 1 )/2;
|
||||
LL ans = L*L/2 + (L + 1) /2;
|
||||
sort(p,p+m,cmp);
|
||||
ans -= unique(p,p+m)-p;
|
||||
if( ans > 0 )
|
||||
{
|
||||
ans = Pow( ans , (LL)k );
|
||||
printf( "%I64d\n",ans );
|
||||
}
|
||||
else printf( "0\n" );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <stack>
|
||||
#include <algorithm>
|
||||
#define lson l, m , rt << 1
|
||||
#define rson m + 1, r, rt << 1 | 1
|
||||
#define maxn 50010
|
||||
using namespace std;
|
||||
struct people{
|
||||
int id,loty,abty;
|
||||
bool operator < (const people& cmp)const {
|
||||
return abty > cmp.abty;
|
||||
}
|
||||
}emp[maxn];
|
||||
int Max[maxn << 2],t,n,m,ans[maxn],L[maxn],R[maxn],head[maxn],tot,ed;
|
||||
map <int, int> mp;
|
||||
struct Edge{
|
||||
int v,next;
|
||||
}edge[maxn];
|
||||
void add(int u,int v){
|
||||
edge[ed].v = v;
|
||||
edge[ed].next = head[u];
|
||||
head[u] = ed ++;
|
||||
}
|
||||
void dfs(int root){
|
||||
bool vis[maxn];
|
||||
memset(vis,0,sizeof(vis));
|
||||
tot = 0; stack <int> ss;
|
||||
while(!ss.empty()){ss.pop();}
|
||||
ss.push(root); vis[root] = true; L[root] = tot ++;
|
||||
while(!ss.empty()){
|
||||
int now = ss.top();
|
||||
bool flag = false;
|
||||
for(int i = head[now]; i != - 1; i = edge[i].next){
|
||||
int x = edge[i].v;
|
||||
if(!vis[x]){
|
||||
flag = true;
|
||||
vis[x] = true;
|
||||
L[x] = tot ++;
|
||||
ss.push(x);
|
||||
head[now] = edge[i].next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag) continue;
|
||||
if(vis[now]){
|
||||
R[now] = tot;
|
||||
ss.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
int query(int L, int R, int l, int r, int rt){
|
||||
if(L > R) return -1;
|
||||
if(L <= l && r <= R){
|
||||
return Max[rt];
|
||||
}int m = (l + r) >> 1;
|
||||
int ll = -1, rr = -1;
|
||||
if(L <= m) ll = query(L,R,lson);
|
||||
if(R > m) rr = query(L,R,rson);
|
||||
return max(ll,rr);
|
||||
}
|
||||
void update(int &pos, int &val, int l, int r, int rt){
|
||||
if(l == r){
|
||||
Max[rt] = val; return ;
|
||||
}int m = (l + r) >> 1;
|
||||
if(pos <= m) update(pos,val,lson);
|
||||
else update(pos,val,rson);
|
||||
Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
|
||||
}
|
||||
void pre(){
|
||||
mp.clear(); mp[-1] = -1; tot = ed = 0;
|
||||
memset(L,0,sizeof(L)); memset(R,0,sizeof(R)); memset(ans,-1,sizeof(ans));
|
||||
memset(head,-1,sizeof(head)); memset(Max,-1,sizeof(Max));
|
||||
for(int i = 1,fa; i < n; i ++){
|
||||
scanf("%d%d%d",&fa,&emp[i].loty, &emp[i].abty);
|
||||
add(fa,i);
|
||||
mp[emp[i].loty] = i;
|
||||
emp[i].id = i;
|
||||
}
|
||||
dfs(0);
|
||||
sort(emp + 1,emp + n);
|
||||
}
|
||||
void showans(){
|
||||
int fired;
|
||||
while(m --){
|
||||
scanf("%d",&fired);
|
||||
printf("%d\n",ans[fired]);
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
scanf("%d",&t);
|
||||
while(t --){
|
||||
scanf("%d%d",&n,&m);
|
||||
pre();
|
||||
for(int i = 1, j; i < n; i = j){
|
||||
j = i;
|
||||
while(j < n && emp[j].abty == emp[i].abty){
|
||||
int id = emp[j].id;
|
||||
int lo = query(L[id] + 1,R[id] - 1,0,tot - 1, 1);
|
||||
ans[id] = mp[lo];
|
||||
j ++;
|
||||
}
|
||||
j = i;
|
||||
while(j < n && emp[j].abty == emp[i].abty){
|
||||
int id = emp[j].id;
|
||||
update(L[id],emp[j].loty,0,tot - 1, 1);
|
||||
j ++;
|
||||
}
|
||||
}
|
||||
showans();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N=210;
|
||||
const int M=41000;
|
||||
const int MOD=1000000007;
|
||||
const double eps=1e-8;
|
||||
const double PI=acos(-1.0);
|
||||
const double PI2=PI*2;
|
||||
struct Point
|
||||
{
|
||||
double x,y;
|
||||
LL index;
|
||||
double angle;
|
||||
inline void input()
|
||||
{
|
||||
scanf("%lf%lf",&x,&y);
|
||||
}
|
||||
}point[N],temp[N];
|
||||
int n;
|
||||
bool visit[M];
|
||||
LL fib[M];
|
||||
LL fk[M];
|
||||
int num[N][N];
|
||||
int left[N][N];
|
||||
int right[N][N];
|
||||
inline Point operator-(const Point &a, const Point &b)
|
||||
{
|
||||
Point c;
|
||||
c.x=a.x-b.x;
|
||||
c.y=a.y-b.y;
|
||||
return c;
|
||||
}
|
||||
inline double operator*(const Point &a, const Point &b)
|
||||
{
|
||||
return a.x*b.y-a.y*b.x;
|
||||
}
|
||||
inline bool operator==(const Point &a, const Point &b)
|
||||
{
|
||||
return a.x==b.x&&a.y==b.y;
|
||||
}
|
||||
inline int cross(const Point &a, const Point &b, const Point &o)
|
||||
{
|
||||
return (a-o)*(b-o)>0? 1:-1;
|
||||
}
|
||||
inline int cross(const int &a, const int &b, const int &o)
|
||||
{
|
||||
return cross(point[a],point[b],point[o]);
|
||||
}
|
||||
inline double positiveAtan(const Point &a, const Point &o)
|
||||
{
|
||||
double res=atan2(a.y-o.y,a.x-o.x);
|
||||
if(res<0)
|
||||
res+=PI2;
|
||||
return res;
|
||||
}
|
||||
bool operator<(const Point &a, const Point &b)
|
||||
{
|
||||
return a.angle<b.angle;
|
||||
}
|
||||
int abs1(int x)
|
||||
{
|
||||
return x<0? -x:x;
|
||||
}
|
||||
int getAngleNumber(int a,int b,int c)
|
||||
{
|
||||
if(point[c].y<point[b].y&&point[a].y>=point[b].y)
|
||||
return n-abs1(right[b][c]-right[b][a]+2)+3;
|
||||
return abs1(right[b][a]-right[b][c])+2;
|
||||
}
|
||||
int getTriangleNumber(int a, int b, int c)
|
||||
{
|
||||
return n-left[a][b]-left[b][c]-left[c][a]+getAngleNumber(a,b,c)+getAngleNumber(b,c,a)+getAngleNumber(c,a,b)-6;
|
||||
}
|
||||
LL quick_mod(LL a,LL b)
|
||||
{
|
||||
LL ans=1;
|
||||
a%=MOD;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
ans=ans*a%MOD;
|
||||
b--;
|
||||
}
|
||||
b>>=1;
|
||||
a=a*a%MOD;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL solve(int x)
|
||||
{
|
||||
if(visit[x])
|
||||
return fk[x];
|
||||
visit[x]=true;
|
||||
fib[0]=x;
|
||||
fib[1]=x;
|
||||
for(int i=2;i<=x;++i)
|
||||
fib[i]=(fib[i-1]*fib[i-2])%MOD;
|
||||
return fk[x]=fib[x]+1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
point[i].input();
|
||||
temp[i]=point[i];
|
||||
temp[i].index=i;
|
||||
}
|
||||
memset(left,0,sizeof(left));
|
||||
memset(right,0,sizeof(right));
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
for(int j=i+1;j<n;++j)
|
||||
{
|
||||
for(int k=0;k<n;++k)
|
||||
{
|
||||
if(k!=i&&k!=j)
|
||||
{
|
||||
if(cross(k,j,i)<0)
|
||||
++left[i][j];
|
||||
else if(cross(k,i,j)<0)
|
||||
++left[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int j=0;j<n;++j)
|
||||
{
|
||||
if(temp[j].index==i)
|
||||
temp[j].angle=-1e100;
|
||||
else
|
||||
temp[j].angle=positiveAtan(temp[j],point[i]);
|
||||
}
|
||||
sort(temp,temp+n);
|
||||
int cnt=0;
|
||||
for(int j=0;j<n;++j)
|
||||
right[i][temp[j].index]=++cnt;
|
||||
}
|
||||
memset(num,0,sizeof(num));
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
for(int j=i+1;j<n;++j)
|
||||
{
|
||||
for(int k=0;k<n;++k)
|
||||
{
|
||||
if(k==i||k==j) continue;
|
||||
if(cross(point[k], point[j], point[i]) < 0)
|
||||
num[i][j]+=getAngleNumber(j,k,i)-getTriangleNumber(i,j,k);
|
||||
}
|
||||
}
|
||||
}
|
||||
LL ans=1;
|
||||
for(int i=0;i<n;++i)
|
||||
for(int j=i+1;j<n;++j)
|
||||
ans=(ans*solve(num[i][j]))%MOD;
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#define eps 1e-5
|
||||
#define PI 3.1415926535897932384626
|
||||
int n,a[10001];
|
||||
double angle;
|
||||
int i,j,k,maxtop;
|
||||
double dis[10001],t,top,ans,low,h;
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%lf",&n,&angle))
|
||||
{
|
||||
if(angle<-eps) for(i=n-1;i>=0;i--) scanf("%d",&a[i]);
|
||||
else for(i=0;i<n;i++) scanf("%d",&a[i]);
|
||||
if(angle<-eps) angle=-angle;
|
||||
angle=PI*angle/180.0;
|
||||
t=-1;ans=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
dis[i]=((i+1)*tan(angle)+a[i]*1.0)/sqrt(tan(angle)*tan(angle)+1);
|
||||
if(t<dis[i]){t=dis[i];maxtop=i;}
|
||||
}
|
||||
for(i=0;i<maxtop;i++)
|
||||
{
|
||||
top=a[i];
|
||||
for(j=i+1;j<=maxtop;j++)
|
||||
{
|
||||
if(dis[j]>dis[i]+eps)
|
||||
{
|
||||
if(dis[j]-sin(angle)>dis[i]+eps)
|
||||
{
|
||||
top-=(j-i-1)*1.0*tan(angle);
|
||||
ans+=(j-i-1)*(j-i-1)*0.5*tan(angle);
|
||||
}
|
||||
else
|
||||
{
|
||||
top-=(a[i]-a[j])*1.0;
|
||||
ans+=(a[i]-a[j])*(a[i]-a[j])*0.5/tan(angle);
|
||||
}
|
||||
for(k=i+1;k<j;k++)
|
||||
ans+=(top-a[k])*1.0;
|
||||
i=j-1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i=n-1;i>maxtop;i--)
|
||||
{
|
||||
for(j=i-1;j>=maxtop;j--)
|
||||
{
|
||||
h=i-j;
|
||||
low=h*tan(angle)-(a[j+1]-a[i]);
|
||||
top=(h-1)*tan(angle)-(a[j+1]-a[i]);
|
||||
ans+=(top+low)/2.0;
|
||||
if(dis[j]>dis[i]+eps)
|
||||
break;
|
||||
}
|
||||
i=j+1;
|
||||
}
|
||||
printf("%.2lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int INF=0x3f3f3f3f;
|
||||
const int MAXN=330;
|
||||
int cost[MAXN][MAXN];
|
||||
int dist[MAXN];
|
||||
int que[MAXN];
|
||||
bool vis[MAXN];
|
||||
void SPFA(int start,int n)
|
||||
{
|
||||
int front=0,rear=0;
|
||||
for(int v=1;v<=n;v++)
|
||||
{
|
||||
if(v==start)
|
||||
{
|
||||
dist[v]=INF;
|
||||
vis[v]=false;
|
||||
}
|
||||
else if(cost[start][v]!=INF)
|
||||
{
|
||||
dist[v]=cost[start][v];
|
||||
que[rear++]=v;
|
||||
vis[v]=true;
|
||||
}
|
||||
else
|
||||
{
|
||||
dist[v]=INF;
|
||||
vis[v]=false;
|
||||
}
|
||||
}
|
||||
while(front!=rear)
|
||||
{
|
||||
int u=que[front++];
|
||||
for(int v=1;v<=n;v++)
|
||||
{
|
||||
if(dist[v]>dist[u]+cost[u][v])
|
||||
{
|
||||
dist[v]=dist[u]+cost[u][v];
|
||||
if(!vis[v])
|
||||
{
|
||||
vis[v]=true;
|
||||
que[rear++]=v;
|
||||
if(rear>=MAXN) rear=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
vis[u]=false;
|
||||
if(front>=MAXN)front=0;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=1;j<=n;j++)
|
||||
scanf("%d",&cost[i][j]);
|
||||
SPFA(1,n);
|
||||
int ans=dist[n];
|
||||
int loop1=dist[1];
|
||||
SPFA(n,n);
|
||||
int loopn=dist[n];
|
||||
ans=min(ans,loop1+loopn);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int test,n,m,tmin,t,i,k;
|
||||
scanf("%d",&test);
|
||||
for(k=1;k<=test;k++)
|
||||
{
|
||||
tmin=1000000;
|
||||
scanf("%d %d",&n,&m);
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d",&t);
|
||||
if(tmin>t)
|
||||
tmin=t;
|
||||
}
|
||||
n=n/tmin;
|
||||
if(n&1) printf("Case #%d: Bob\n",k);
|
||||
else printf("Case #%d: Alice\n",k);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N=2005;
|
||||
const LL MOD=1000000007;
|
||||
LL C[N][N];
|
||||
LL S[N][N];
|
||||
void Init()
|
||||
{
|
||||
int i,j;
|
||||
for(i=0;i<N;i++)
|
||||
{
|
||||
C[i][0]=1;
|
||||
C[i][i]=1;
|
||||
S[i][0]=0;
|
||||
S[i][i]=1;
|
||||
for(j=1;j<i;j++)
|
||||
{
|
||||
C[i][j]=(C[i-1][j]%MOD+C[i-1][j-1]%MOD)%MOD;
|
||||
S[i][j]=((i-1)%MOD*S[i-1][j]%MOD+S[i-1][j-1]%MOD);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
LL t,n,f,b,ans;
|
||||
Init();
|
||||
scanf("%I64d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%I64d%I64d%I64d",&n,&f,&b);
|
||||
ans=C[f+b-2][f-1]%MOD*S[n-1][f+b-2]%MOD;
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<queue>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<iomanip>
|
||||
using namespace std;
|
||||
#define i64 __int64
|
||||
#define MM(name,what) memset(name,what,sizeof(name))
|
||||
const int inf = 0x3f3f3f3f;
|
||||
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
|
||||
const double oo = 10e9;
|
||||
const double eps = 10e-9;
|
||||
const double pi = acos(-1.0);
|
||||
const int maxn = 100111;
|
||||
const i64 mod = 364875103;
|
||||
const i64 mod1 = 97;
|
||||
const i64 mod2 = 3761599;
|
||||
const int maxc = 111;
|
||||
i64 gcd(i64 _a, i64 _b)
|
||||
{
|
||||
if (!_a || !_b)
|
||||
{
|
||||
return max(_a, _b);
|
||||
}
|
||||
i64 _t;
|
||||
while ((_t = _a % _b))
|
||||
{
|
||||
_a = _b;
|
||||
_b = _t;
|
||||
}
|
||||
return _b;
|
||||
}
|
||||
i64 ext_gcd (i64 _a, i64 _b, i64 &_x, i64 &_y)
|
||||
{
|
||||
if (!_b)
|
||||
{
|
||||
_x = 1;
|
||||
_y = 0;
|
||||
return _a;
|
||||
}
|
||||
i64 _d = ext_gcd (_b, _a % _b, _x, _y);
|
||||
i64 _t = _x;
|
||||
_x = _y;
|
||||
_y = _t - _a / _b * _y;
|
||||
return _d;
|
||||
}
|
||||
i64 invmod (i64 _a, i64 _p)
|
||||
{
|
||||
i64 _ans, _y;
|
||||
ext_gcd (_a, _p, _ans, _y);
|
||||
_ans < 0 ? _ans += _p : 0;
|
||||
return _ans;
|
||||
}
|
||||
i64 dp[maxn];
|
||||
i64 inv[maxn];
|
||||
i64 c[maxc][maxc];
|
||||
i64 n,m;
|
||||
i64 ans;
|
||||
i64 a[21];
|
||||
i64 cx;
|
||||
void init()
|
||||
{
|
||||
for(int i=1;i<maxn;i++)
|
||||
{
|
||||
inv[i]=invmod(i,mod2);
|
||||
}
|
||||
MM(c,0);
|
||||
for(int i=0;i<maxc;i++)
|
||||
{
|
||||
c[i][i]=1;
|
||||
c[i][0]=1;
|
||||
}
|
||||
for(int i=1;i<maxc;i++)
|
||||
{
|
||||
for(int j=1;j<maxc;j++)
|
||||
{
|
||||
c[i][j]=c[i-1][j-1]+c[i-1][j];
|
||||
c[i][j]%=mod1;
|
||||
}
|
||||
}
|
||||
cx = invmod(mod1,mod2);
|
||||
return ;
|
||||
}
|
||||
i64 lucas(i64 x,i64 y,i64 p=mod1)
|
||||
{
|
||||
if(y>x) return 0;
|
||||
i64 re=1;
|
||||
i64 dx = x%p;
|
||||
i64 dy = y%p;
|
||||
re*=c[dx][dy];
|
||||
dx = x/p;
|
||||
dy = y/p;
|
||||
if(dx || dy)
|
||||
{
|
||||
re*=lucas(dx,dy);
|
||||
}
|
||||
re%=p;
|
||||
return re;
|
||||
}
|
||||
i64 find(int x)
|
||||
{
|
||||
i64 t1 = lucas(n+x-1,x);
|
||||
i64 t2 = dp[x];
|
||||
i64 temp = cx;
|
||||
temp *= t2-t1;
|
||||
temp %= mod2;
|
||||
temp = (temp+mod2)%mod2;
|
||||
temp *= mod1;
|
||||
temp += t1;
|
||||
temp %= mod;
|
||||
return temp;
|
||||
}
|
||||
void start()
|
||||
{
|
||||
dp[0]=1;
|
||||
i64 now,temp;
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
now = n+i-1;
|
||||
dp[i]=dp[i-1]*now;
|
||||
dp[i]%=mod2;
|
||||
dp[i]*=inv[i];
|
||||
dp[i]%=mod2;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int k,T;
|
||||
cin>>T;
|
||||
for(int tt=1;tt<=T;tt++)
|
||||
{
|
||||
cin>>n>>m;
|
||||
start();
|
||||
cin>>k;
|
||||
for(int i=1;i<=k;i++)
|
||||
{
|
||||
cin>>a[i];
|
||||
a[i]++;
|
||||
}
|
||||
ans=1;
|
||||
i64 pre = m;
|
||||
i64 now;
|
||||
for(int i=k;i>=1;i--)
|
||||
{
|
||||
now = pre - a[i]+1;
|
||||
ans *= find(now);
|
||||
ans %= mod;
|
||||
pre = a[i]-1;
|
||||
}
|
||||
cout<<"Case #"<<tt<<": "<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#define eps 1e-5
|
||||
#define MAXN 105
|
||||
#define MAXM 11111
|
||||
#define INF 1000000000
|
||||
#define lch(x) x<<1
|
||||
#define rch(x) x<<1|1
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
using namespace std;
|
||||
int n, m, x, t;
|
||||
int in()
|
||||
{
|
||||
int flag = 1;
|
||||
char ch;
|
||||
int a = 0;
|
||||
while((ch = getchar()) == ' ' || ch == '\n');
|
||||
if(ch == '-') flag = -1;
|
||||
else
|
||||
a += ch - '0';
|
||||
while((ch = getchar()) != ' ' && ch != '\n')
|
||||
{
|
||||
a *= 10;
|
||||
a += ch - '0';
|
||||
}
|
||||
return flag * a;
|
||||
}
|
||||
int dp[MAXN][MAXM];
|
||||
int sum[MAXN][MAXM];
|
||||
int lmx[4 * MAXM];
|
||||
int rmx[4 * MAXM];
|
||||
int a[MAXN][MAXM];
|
||||
int q[MAXM];
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d%d%d", &n, &m, &x, &t) != EOF)
|
||||
{
|
||||
for(int i = 1; i <= n + 2; i++)
|
||||
for(int j = 1; j <= m; j++)
|
||||
sum[i][j] = 0, dp[i][j] = -INF, a[i][j] = 0;
|
||||
for(int i = 1; i <= n; i++)
|
||||
for(int j = 1; j <= m; j++)
|
||||
{
|
||||
a[i][j] = in();
|
||||
sum[i][j] = sum[i][j - 1] + a[i][j];
|
||||
}
|
||||
int tmp = 0;
|
||||
for(int i = x; i <= x + t; i++)
|
||||
{
|
||||
tmp += a[1][i];
|
||||
dp[1][i] = tmp;
|
||||
dp[2][i] = dp[1][i] + a[2][i];
|
||||
}
|
||||
tmp = 0;
|
||||
for(int i = x; i >= x - t; i--)
|
||||
{
|
||||
tmp += a[1][i];
|
||||
dp[1][i] = tmp;
|
||||
dp[2][i] = dp[1][i] + a[2][i];
|
||||
}
|
||||
for(int i = 3; i <= n + 1; i++)
|
||||
{
|
||||
for(int j = 1; j <= m; j++)
|
||||
{
|
||||
lmx[j] = dp[i - 1][j] - sum[i - 1][j];
|
||||
rmx[j] = dp[i - 1][j] + sum[i - 1][j - 1];
|
||||
}
|
||||
int head = 1, rear = 0;
|
||||
for(int j = 1; j <= m; j++)
|
||||
{
|
||||
while(head <= rear && lmx[q[rear]] <= lmx[j]) rear--;
|
||||
q[++rear] = j;
|
||||
while(head <= rear && q[head] < j - t) head++;
|
||||
dp[i][j] = max(lmx[q[head]] + sum[i - 1][j] + a[i][j], dp[i][j]);
|
||||
}
|
||||
head = 1, rear = 0;
|
||||
for(int j = m; j >= 1; j--)
|
||||
{
|
||||
while(head <= rear && rmx[q[rear]] <= rmx[j]) rear--;
|
||||
q[++rear] = j;
|
||||
while(head <= rear && q[head] > j + t) head++;
|
||||
dp[i][j] = max(rmx[q[head]] - sum[i - 1][j - 1] + a[i][j], dp[i][j]);
|
||||
}
|
||||
}
|
||||
int ans = -INF;
|
||||
for(int i = 1; i <= m; i++)
|
||||
if(dp[n + 1][i] > ans) ans = dp[n + 1][i];
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include<iostream>
|
||||
#include<sstream>
|
||||
#include<vector>
|
||||
#include<list>
|
||||
#include<deque>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<bitset>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<cctype>
|
||||
#include<cmath>
|
||||
#include<ctime>
|
||||
#include<iomanip>
|
||||
using namespace std;
|
||||
const double eps(1e-8);
|
||||
typedef long long lint;
|
||||
int dx[] = {-1, 0, 1, 0};
|
||||
int dy[] = {0, 1, 0, -1};
|
||||
int H, W, N;
|
||||
#define next nex
|
||||
char lr[1000100];
|
||||
int next[1000100][4];
|
||||
int dir[1000100];
|
||||
const int inf = 1e9 + 7;
|
||||
char maz[1010][1010];
|
||||
int vis[1010][1010][4];
|
||||
int sx, sy, ex, ey;
|
||||
#define mp make_pair
|
||||
int cas;
|
||||
int tot;
|
||||
struct Edge
|
||||
{
|
||||
int x, y, nex;
|
||||
};
|
||||
Edge edge[4000010];
|
||||
int head[1000010];
|
||||
void addEdge(int s, int x, int y)
|
||||
{
|
||||
edge[tot].x = x, edge[tot].y = y;
|
||||
edge[tot].nex = head[s];
|
||||
head[s] = tot++;
|
||||
}
|
||||
bool bfs()
|
||||
{
|
||||
memset(head, -1, sizeof(head));
|
||||
tot = 0;
|
||||
while(sx >= 0 && sx < H && sy >= 0 && sy < W && vis[sx][sy][0] != cas && maz[sx][sy] != '#')
|
||||
{
|
||||
addEdge(0, sx, sy);
|
||||
vis[sx][sy][0] = cas;
|
||||
if(sx == ex && sy == ey) return true;
|
||||
sx += dx[0], sy += dy[0];
|
||||
}
|
||||
for(int i = 0; i <= N; i++)
|
||||
{
|
||||
for(int j = head[i]; j + 1; j = edge[j].nex)
|
||||
{
|
||||
int nx = edge[j].x, ny = edge[j].y;
|
||||
for(int d = 0; d < 4; d++)
|
||||
{
|
||||
if(next[i][d] == inf) continue;
|
||||
int tx = nx + dx[d], ty = ny + dy[d];
|
||||
while(tx >= 0 && tx < H && ty >= 0 && ty < W && vis[tx][ty][d] != cas && maz[tx][ty] != '#')
|
||||
{
|
||||
addEdge(next[i][d], tx, ty);
|
||||
vis[tx][ty][d] = cas;
|
||||
if(tx == ex && ty == ey) return true;
|
||||
tx += dx[d], ty += dy[d];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
dir[0] = 0;
|
||||
for(int i = 0; i < N; i++)
|
||||
dir[i + 1] = (lr[i] == 'L') ? (dir[i] + 3) % 4 : (dir[i] + 1) % 4;
|
||||
int last[4] = {inf, inf, inf, inf};
|
||||
for(int i = N; i >= 0; i--)
|
||||
{
|
||||
for(int j = 0; j < 4; j++)
|
||||
next[i][j] = last[j];
|
||||
last[dir[i]] = i;
|
||||
}
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cas = 0;
|
||||
memset(vis, 0, sizeof(vis));
|
||||
while(~scanf("%d %d %d", &H, &W, &N))
|
||||
{
|
||||
cas++;
|
||||
scanf("%s", lr);
|
||||
init();
|
||||
for(int i = 0; i < H; i++)
|
||||
{
|
||||
scanf("%s", maz[i]);
|
||||
for(int j = 0; j < W; j++)
|
||||
if(maz[i][j] == 'S') sx = i, sy = j;
|
||||
else if(maz[i][j] == 'E') ex = i, ey = j;
|
||||
}
|
||||
if(bfs()) puts("Yes");
|
||||
else puts("No");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,171 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MAXL 22
|
||||
#define KIND 9
|
||||
#define MAXNODE 42
|
||||
typedef long long LL;
|
||||
vector<int> A, B, RA, RB;
|
||||
char subA[MAXL], subB[MAXL];
|
||||
int N, en[MAXNODE], suffix[MAXNODE], q[MAXNODE], child[MAXNODE][KIND];
|
||||
LL dp[MAXL][3][3][3][3][MAXNODE][1 << 2];
|
||||
int change(char ch) {
|
||||
return ch - '1';
|
||||
}
|
||||
void Trie() {
|
||||
memset(en, 0, sizeof(en));
|
||||
memset(child, 0, sizeof(child));
|
||||
N = 1;
|
||||
for(int i = 0; i < 2; ++i) {
|
||||
char* s = i == 0? subA: subB;
|
||||
int p = 1;
|
||||
for (int j = 0; s[j]; ++j) {
|
||||
int ch = change(s[j]);
|
||||
if (!child[p][ch]) child[p][ch] = ++N;
|
||||
p = child[p][ch];
|
||||
}
|
||||
en[p] |= 1 << i;
|
||||
}
|
||||
}
|
||||
void AC() {
|
||||
int ql = 0, qr = 0;
|
||||
for (int i = 0; i < KIND; ++i)
|
||||
if (child[1][i]) {
|
||||
suffix[child[1][i]] = 1;
|
||||
q[qr++] = child[1][i];
|
||||
}
|
||||
else child[1][i] = 1;
|
||||
while (ql < qr) {
|
||||
int u = q[ql++];
|
||||
for (int i = 0; i < KIND; ++i)
|
||||
if (child[u][i]) {
|
||||
suffix[child[u][i]] = child[suffix[u]][i];
|
||||
q[qr++] = child[u][i];
|
||||
}
|
||||
else child[u][i] = child[suffix[u]][i];
|
||||
}
|
||||
for (int i = 1; i <= N; ++i)
|
||||
for (int j = i; j != 1; j = suffix[j]) en[i] |= en[j];
|
||||
}
|
||||
int cal1(int pos, int val, int pre, vector<int>& vec) {
|
||||
if(pos >= vec.size()) return 2;
|
||||
if(pre != 0) return pre;
|
||||
if(val > vec[pos]) return 2;
|
||||
if(val < vec[pos]) return 1;
|
||||
return 0;
|
||||
}
|
||||
int cal2(int pos, int val, int pre, vector<int>& vec) {
|
||||
if(pos >= vec.size()) return 2;
|
||||
if(val > vec[pos]) return 2;
|
||||
if(val < vec[pos]) return 1;
|
||||
return pre;
|
||||
}
|
||||
int main() {
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
for(int cas = 1; cas <= T; ++cas) {
|
||||
LL a, b;
|
||||
cin >> a >> b;
|
||||
scanf("%s%s", subA, subB);
|
||||
LL sub = 0, rsub = 0;
|
||||
for(int i = 0; subA[i]; ++i)
|
||||
sub = sub * 10 + subA[i] - '0';
|
||||
for(int i = 0; subB[i]; ++i)
|
||||
rsub = rsub * 10 + subB[i] - '0';
|
||||
reverse(subB, subB + strlen(subB));
|
||||
Trie();
|
||||
AC();
|
||||
A.clear();
|
||||
B.clear();
|
||||
RA.clear();
|
||||
RB.clear();
|
||||
LL ta = a, tb = b;
|
||||
while(ta) {
|
||||
RA.push_back(ta % 10);
|
||||
ta /= 10;
|
||||
}
|
||||
while(tb) {
|
||||
RB.push_back(tb % 10);
|
||||
tb /= 10;
|
||||
}
|
||||
A = RA;
|
||||
B = RB;
|
||||
reverse(A.begin(), A.end());
|
||||
reverse(B.begin(), B.end());
|
||||
int l = B.size();
|
||||
memset(dp, 0, sizeof(dp));
|
||||
for(int j = 1; j < 10; ++j) {
|
||||
int s1 = cal1(0, j, 0, A);
|
||||
int s2 = cal1(0, j, 0, B);
|
||||
int rs1 = cal2(0, j, 0, RA);
|
||||
int rs2 = cal2(0, j, 0, RB);
|
||||
int v = child[1][j - 1];
|
||||
++dp[0][s1][s2][rs1][rs2][v][en[v]];
|
||||
}
|
||||
for(int i = 0; i + 1 < l; ++i) {
|
||||
for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
|
||||
for(int u = 1; u <= N; ++u)
|
||||
for(int mask = 0; mask < (1 << 2); ++mask) if(dp[i][s1][s2][rs1][rs2][u][mask]) {
|
||||
for(int val = 1; val < 10; ++val) {
|
||||
int ns1 = cal1(i + 1, val, s1, A);
|
||||
int ns2 = cal1(i + 1, val, s2, B);
|
||||
int nrs1 = cal2(i + 1, val, rs1, RA);
|
||||
int nrs2 = cal2(i + 1, val, rs2, RB);
|
||||
int v = child[u][val - 1];
|
||||
dp[i + 1][ns1][ns2][nrs1][nrs2][v][mask | en[v]] += dp[i][s1][s2][rs1][rs2][u][mask];
|
||||
}
|
||||
}
|
||||
}
|
||||
LL res = 0;
|
||||
int la = A.size(), lb = B.size();
|
||||
for(int len = la; len < lb - 1; ++len) {
|
||||
for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
|
||||
for(int u = 1; u <= N; ++u)
|
||||
for(int mask = 1; mask < (1 << 2); ++mask)
|
||||
res += dp[len][s1][s2][rs1][rs2][u][mask];
|
||||
}
|
||||
if(la != lb) {
|
||||
for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
|
||||
for(int u = 1; u <= N; ++u)
|
||||
for(int mask = 1; mask < (1 << 2); ++mask) {
|
||||
bool flaga = false;
|
||||
if(mask == 1 || mask == 3) {
|
||||
if(s1 == 0 || s1 == 2) flaga = true;
|
||||
}
|
||||
if(mask == 2 || mask == 3) {
|
||||
if(rs1 == 0 || rs1 == 2) flaga = true;
|
||||
}
|
||||
if(flaga)
|
||||
res += dp[la - 1][s1][s2][rs1][rs2][u][mask];
|
||||
bool flagb = false;
|
||||
if(mask == 1 || mask == 3) {
|
||||
if(s2 == 0 || s2 == 1) flagb = true;
|
||||
}
|
||||
if(mask == 2 || mask == 3) {
|
||||
if(rs2 == 0 || rs2 == 1) flagb = true;
|
||||
}
|
||||
if(flagb)
|
||||
res += dp[lb - 1][s1][s2][rs1][rs2][u][mask];
|
||||
}
|
||||
} else {
|
||||
for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
|
||||
for(int u = 1; u <= N; ++u)
|
||||
for(int mask = 1; mask < (1 << 2); ++mask) {
|
||||
bool flag = false;
|
||||
if(mask == 1 || mask == 3) {
|
||||
if((s1 == 0 || s1 == 2) && (s2 == 0 || s2 == 1)) flag = true;
|
||||
}
|
||||
if(mask == 2 || mask == 3) {
|
||||
if((rs1 == 0 || rs1 == 2) && (rs2 == 0 || rs2 == 1)) flag = true;
|
||||
}
|
||||
if(flag) res += dp[la - 1][s1][s2][rs1][rs2][u][mask];
|
||||
}
|
||||
}
|
||||
printf("Case #%d: ", cas);
|
||||
cout << res << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
int T,n;
|
||||
int i,j,qujian[100001],began,t,res;
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
t=(int)(sqrt(n)+0.99999);
|
||||
res=t*t-n;
|
||||
for(i=0;i<t;i++) qujian[i]=t;
|
||||
for(i=0;i<t;i++)
|
||||
if(qujian[i]<res+1)
|
||||
{
|
||||
qujian[i]=1;
|
||||
res-=(t-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
qujian[i]-=res;
|
||||
break;
|
||||
}
|
||||
began=0;
|
||||
for(i=0;i<t;i++)
|
||||
{
|
||||
began+=qujian[i];
|
||||
for(j=0;j<qujian[i];j++)
|
||||
if(i==t-1&&j==qujian[i]-1) printf("%d\n",began-j);
|
||||
else printf("%d ",began-j);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
unsigned int a,b,k,n,l,last;
|
||||
unsigned int mod;
|
||||
bool v[21000000];
|
||||
int main()
|
||||
{
|
||||
while(cin>>n>>l>>a>>b>>mod)
|
||||
{
|
||||
for(unsigned int i=1;i<=n;i++)
|
||||
v[i]=false;
|
||||
unsigned int ans=0;unsigned int max=0,t;
|
||||
last=b;
|
||||
for(unsigned int i=1;i<=n;i++)
|
||||
{
|
||||
t=(last+a)%mod;
|
||||
if(t*2<=l)
|
||||
{
|
||||
ans++;v[i]=true;
|
||||
if(t>max)max=t;
|
||||
}
|
||||
last=t;
|
||||
}
|
||||
last=b;
|
||||
for(unsigned int i=1;i<=n;i++)
|
||||
{
|
||||
t=(last+a)%mod;
|
||||
if((!v[i])&&t+max<=l){ans++;break;}
|
||||
last=t;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N=105;
|
||||
const int M=1005;
|
||||
struct Point
|
||||
{
|
||||
LL x,y;
|
||||
}P1[N],P2[M];
|
||||
int f[N][N][N];
|
||||
int n,m;
|
||||
LL cross(Point a,Point b,Point s)
|
||||
{
|
||||
LL x1=a.x-s.x,y1=a.y-s.y;
|
||||
LL x2=b.x-s.x,y2=b.y-s.y;
|
||||
return x1*y2-x2*y1;
|
||||
}
|
||||
int dis2(Point a,Point b)
|
||||
{
|
||||
return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*((a.y-b.y));
|
||||
}
|
||||
int cmp(Point a,Point b)
|
||||
{
|
||||
if(cross(a,b,P1[0])>0)
|
||||
return 1;
|
||||
else return 0;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i,t;
|
||||
for(t=0,i=0;i<n;i++){
|
||||
if((P1[i].y-P1[t].y)<0 || (P1[i].y-P1[t].y==0 && P1[i].x-P1[t].x<0))
|
||||
t=i;
|
||||
}
|
||||
swap(P1[0],P1[t]);
|
||||
sort(P1+1,P1+n,cmp);
|
||||
}
|
||||
int cal(int x,int y,int z)
|
||||
{
|
||||
int i;
|
||||
int sum=0;
|
||||
LL a,b,c;
|
||||
for (i=0;i<m;i++)
|
||||
{
|
||||
a=cross(P1[y],P2[i],P1[x]);
|
||||
b=cross(P1[z],P2[i],P1[y]);
|
||||
c=cross(P1[x],P2[i],P1[z]);
|
||||
if ((a>=0 && b>=0 && c>=0) || (a<=0 && b<=0 && c<=0))
|
||||
{
|
||||
sum++;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
int CA=0;
|
||||
int ans=0;
|
||||
while (scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
ans=0;
|
||||
memset(P1,0,sizeof(P1));
|
||||
memset(P2,0,sizeof(P2));
|
||||
memset(f,0,sizeof(f));
|
||||
for (i=0;i<n;i++)
|
||||
scanf("%I64d%I64d",&P1[i].x,&P1[i].y);
|
||||
for (i=0;i<m;i++)
|
||||
scanf("%I64d%I64d",&P2[i].x,&P2[i].y);
|
||||
init();
|
||||
for (i=2;i<n;i++){
|
||||
for (j=1;j<i;j++){
|
||||
f[0][j][i]=cal(0,j,i);
|
||||
if (f[0][j][i]%2!=0) ans++;
|
||||
}
|
||||
}
|
||||
for (i=2;i<n;i++)
|
||||
for (j=1;j<i;j++)
|
||||
for (k=j+1;k<i;k++){
|
||||
if (cross(P1[k],P1[i],P1[j])>0)
|
||||
f[j][k][i]=f[0][j][k]+f[0][k][i]-f[0][j][i];
|
||||
else
|
||||
f[j][k][i]=f[0][j][i]-(f[0][j][k]+f[0][k][j]);
|
||||
if (f[j][k][i]%2!=0) ans++;
|
||||
}
|
||||
printf("Case %d: ",++CA);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int maxn = 2005;
|
||||
struct node{
|
||||
int aa,cor;
|
||||
node(){}
|
||||
node(int _aa,int _cor){
|
||||
aa = _aa; cor = _cor;
|
||||
}
|
||||
}x1[maxn],x2[maxn];
|
||||
int n,m;
|
||||
int dp1[maxn],dp2[maxn];
|
||||
int sumx1,sumx2;
|
||||
bool cmp(const node &p,const node &q){
|
||||
return p.aa < q.aa;
|
||||
}
|
||||
int min(int a,int b)
|
||||
{
|
||||
return a<b?a:b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas,ta=1;
|
||||
scanf("%d",&cas);
|
||||
while(cas--){
|
||||
int i,j;
|
||||
scanf("%d%d",&n,&m);
|
||||
sumx1 = sumx2 = 1;
|
||||
for(i=0; i<m; i++){
|
||||
int key,yy,z;
|
||||
scanf("%d%d%d",&key,&yy,&z);
|
||||
if(key == 1){
|
||||
x1[sumx1++] = node(yy,z);
|
||||
}else{
|
||||
x2[sumx2++] = node(n+1-yy,z);
|
||||
}
|
||||
}
|
||||
sort(x1+1,x1+sumx1,cmp);
|
||||
sort(x2+1,x2+sumx2,cmp);
|
||||
memset(dp1,0x3f,sizeof(dp1));
|
||||
memset(dp2,0x3f,sizeof(dp2));
|
||||
dp1[0] = dp2[0] = 0;
|
||||
for(i=1; i<sumx1; i++){
|
||||
for(j=x1[i].aa; j>=x1[i].cor; j--){
|
||||
dp1[j] = min(dp1[j],dp1[j-x1[i].cor]+1);
|
||||
}
|
||||
}
|
||||
for(i=1; i<sumx2; i++){
|
||||
for(j=x2[i].aa; j>=x2[i].cor; j--){
|
||||
dp2[j] = min(dp2[j],dp2[j-x2[i].cor]+1);
|
||||
}
|
||||
}
|
||||
int ans = 0,anssum = 0,tmp;
|
||||
for(i=1; i<=n; i++){
|
||||
for(j=0; j<=i; j++){
|
||||
tmp = dp1[j] + dp2[i-j];
|
||||
if(tmp <= m){
|
||||
if(ans != i){
|
||||
ans = i; anssum = tmp;
|
||||
}else if(tmp < anssum){
|
||||
anssum = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: %d %d\n",ta++,ans,anssum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
SET|ADD C1|C2, C1|C2|IntegerNumber
|
||||
MUL C1|C2, IntegerNumber
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<deque>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#define iinf 2000000000
|
||||
#define linf 1000000000000000000LL
|
||||
#define dinf 1e200
|
||||
#define eps 1e-5
|
||||
#define lng long long
|
||||
#define sqr(a) ((a)*(a))
|
||||
#define pi 3.14159265359
|
||||
#define ff(i,xi,n) for(int i=xi;i<=(int)(n);++i)
|
||||
#define ffd(i,xi,n) for(int i=xi;i>=(int)(n);--i)
|
||||
#define ffl(i,r) for(int i=head[r];i!=-1;i=edge[i].next)
|
||||
#define cc(i,j) memset(i,j,sizeof(i))
|
||||
#define two(x) ((lng)1<<(x))
|
||||
#define N 11111
|
||||
#define M 1000000
|
||||
#define lson l , mid , rt << 1
|
||||
#define rson mid + 1 , r , rt << 1 | 1
|
||||
#define Mod n
|
||||
#define Pmod(x) (x%Mod+Mod)%Mod
|
||||
using namespace std;
|
||||
typedef vector<int> vi;
|
||||
typedef vector<string> vs;
|
||||
typedef unsigned int uint;
|
||||
typedef unsigned lng ulng;
|
||||
template<class T> inline void checkmax(T &x,T y){if(x<y) x=y;}
|
||||
template<class T> inline void checkmin(T &x,T y){if(x>y) x=y;}
|
||||
template<class T> inline T Min(T x,T y){return (x>y?y:x);}
|
||||
template<class T> inline T Max(T x,T y){return (x<y?y:x);}
|
||||
template<class T> T gcd(T a,T b){return (a%b)==0?b:gcd(b,a%b);}
|
||||
template<class T> T lcm(T a,T b){return a*b/gcd(a,b);}
|
||||
template<class T> T Abs(T a){return a>0?a:(-a);}
|
||||
template<class T> inline T lowbit(T n){return (n^(n-1))&n;}
|
||||
template<class T> inline int countbit(T n){return (n==0)?0:(1+countbit(n&(n-1)));}
|
||||
template<class T> inline bool isPrimeNumber(T n)
|
||||
{if(n<=1)return false;for (T i=2;i*i<=n;i++) if (n%i==0) return false;return true;}
|
||||
template<class T> inline T Minmin(T a,T b,T c,T d){return Min(Min(a,b),Min(c,d));}
|
||||
int dp[N][2][2],ini[N],head[N],tot,n;
|
||||
struct pp
|
||||
{
|
||||
int v,next;
|
||||
}edge[N*2];
|
||||
inline void add(int u,int v)
|
||||
{
|
||||
edge[tot].v=v;
|
||||
edge[tot].next=head[u];
|
||||
head[u]=tot++;
|
||||
}
|
||||
void dfs(int r,int pre)
|
||||
{
|
||||
int clo=ini[r],rev=1-clo;
|
||||
int sum=0,dps[3]={};
|
||||
dps[1]=dps[2]=iinf;
|
||||
ffl(i,r)
|
||||
{
|
||||
int v=edge[i].v;
|
||||
if(v==pre) continue;
|
||||
dfs(v,r);
|
||||
sum+=dp[v][clo][0];
|
||||
dps[2]=Min(dps[1]+dp[v][rev][1],dps[2]+dp[v][rev][0]);
|
||||
dps[1]=Min(dps[0]+dp[v][rev][1],dps[1]+dp[v][rev][0]);
|
||||
dps[0]+=dp[v][rev][0];
|
||||
}
|
||||
dp[r][clo][0]=Minmin(sum,dps[0]+2,dps[1]+2,dps[2]+2);
|
||||
dp[r][clo][1]=Min(dps[1]+1,dps[0]+1);
|
||||
dp[r][rev][0]=Minmin(sum+1,dps[0]+1,dps[1]+1,dps[2]+1);
|
||||
dp[r][rev][1]=Min(dps[0],dps[1]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int o=0;
|
||||
while(scanf("%d",&n)==1)
|
||||
{
|
||||
cc(head,-1);
|
||||
tot=0;
|
||||
ff(i,2,n)
|
||||
{
|
||||
int u,v;
|
||||
scanf("%d%d",&u,&v);
|
||||
add(u,v);
|
||||
add(v,u);
|
||||
}
|
||||
ff(i,1,n)
|
||||
scanf("%d",ini+i);
|
||||
dfs(1,-1);
|
||||
printf("Case %d: %d\n",++o,Min(dp[1][0][0],dp[1][1][0]));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define clr(x)memset(x,0,sizeof(x))
|
||||
#define min(a,b)(a)<(b)?(a):(b)
|
||||
#define INF 0x1f1f1f1f
|
||||
#define N 21
|
||||
struct node
|
||||
{
|
||||
int x,y;
|
||||
}p[N],be;
|
||||
int dis(node a,node b)
|
||||
{
|
||||
return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
|
||||
}
|
||||
int g[N][N];
|
||||
int dp[1<<N];
|
||||
int pre[1<<N];
|
||||
struct ans
|
||||
{
|
||||
int fi,se,num;
|
||||
}res[N];
|
||||
bool cmp(ans a,ans b)
|
||||
{
|
||||
return a.fi<b.fi;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ca=1,n,i,j,k,t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d %d",&be.x,&be.y);
|
||||
scanf("%d",&n);
|
||||
p[n]=be;
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d%d",&p[i].x,&p[i].y);
|
||||
memset(dp,INF,sizeof(dp));
|
||||
pre[0]=0;
|
||||
int st=1<<n;
|
||||
dp[0]=0;
|
||||
for(i=0;i<=n;i++)
|
||||
for(j=0;j<=n;j++)
|
||||
g[i][j]=dis(p[i],p[j]);
|
||||
printf("Case %d:\n",ca++);
|
||||
int stat,tmp,ss;
|
||||
for(i=0;i<st;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
if((1<<j)&i)
|
||||
continue;
|
||||
stat=i|(1<<j);
|
||||
tmp=dp[i]+g[n][j]*2;
|
||||
if(tmp<dp[stat])
|
||||
{
|
||||
dp[stat]=tmp;
|
||||
pre[stat]=i;
|
||||
}
|
||||
for(k=j+1;k<n;k++)
|
||||
{
|
||||
if((1<<k)&i)
|
||||
continue;
|
||||
ss=stat|(1<<k);
|
||||
tmp=dp[i]+g[n][j]+g[j][k]+g[n][k];
|
||||
if(tmp<dp[ss])
|
||||
{
|
||||
dp[ss]=tmp;
|
||||
pre[ss]=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
st-=1;
|
||||
printf("%d\n",dp[st]);
|
||||
int top=0;
|
||||
while(st)
|
||||
{
|
||||
stat=pre[st]^st;
|
||||
st=pre[st];
|
||||
res[top].num=0;
|
||||
for(i=0;i<n;i++)
|
||||
if((1<<i)&stat)
|
||||
{
|
||||
res[top].num++;
|
||||
if(res[top].num==1)
|
||||
res[top].fi=i+1;
|
||||
else res[top].se=i+1;
|
||||
}
|
||||
top++;
|
||||
}
|
||||
sort(res,res+top,cmp);
|
||||
for(i=0;i<top;i++)
|
||||
{
|
||||
if(res[i].num==1)
|
||||
printf("%d%c",res[i].fi,i==top-1?'\n':' ');
|
||||
else
|
||||
printf("%d %d%c",res[i].fi,res[i].se,i==top-1?'\n':' ');
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include<math.h>
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
int a,b,c,d,max,count=0;
|
||||
double p,ans;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d%d%d",&a,&b,&c,&d);
|
||||
if(a>b) max=a;
|
||||
else max=b;
|
||||
if(max<b) max=b;
|
||||
if(max<c) max=c;
|
||||
if(max<d) max=d;
|
||||
if(max-(a+b+c+d-max)>=0)
|
||||
{
|
||||
printf("Case %d: -1\n",++count);
|
||||
continue;
|
||||
}
|
||||
p=(a+b+c+d)*1.0/2;
|
||||
ans=sqrt((p-a)*(p-b)*(p-c)*(p-d));
|
||||
printf("Case %d: %.6lf\n",++count,ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int n,k;
|
||||
int main(void)
|
||||
{
|
||||
int cas = 1;
|
||||
while(scanf("%d %d",&n,&k)!=EOF){
|
||||
printf("Case %d: ",cas++);
|
||||
int r = n - 2 * k;
|
||||
int ans = 1;
|
||||
bool sig = true;
|
||||
if(r&1){
|
||||
if(k == 1) sig = false;
|
||||
else if(r == 1) ans = k;
|
||||
}
|
||||
if(sig)
|
||||
printf("Alice %d\n",ans);
|
||||
else
|
||||
puts("Bob");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int getOneNumber(int x)
|
||||
{
|
||||
int count = 0;
|
||||
for(int i=0;(1<<i)<=x;++i)
|
||||
{
|
||||
if(x & (1 << i))
|
||||
{
|
||||
++ count;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int caseNumber;
|
||||
int n, m, a;
|
||||
scanf("%d", &caseNumber);
|
||||
for(int cas=1;cas<=caseNumber;++cas)
|
||||
{
|
||||
scanf("%d", &n);
|
||||
int a = 0;
|
||||
while(n--)
|
||||
{
|
||||
scanf("%d", &m);
|
||||
if(!(getOneNumber(m) & 1))
|
||||
{
|
||||
++ a;
|
||||
}
|
||||
}
|
||||
printf("Case %d: ", cas);
|
||||
if(a & 1)
|
||||
{
|
||||
printf("Yes\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("No\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
Here is a function f(x):
|
||||
int f ( int x ) {
|
||||
if ( x == 0 ) return 0;
|
||||
return f ( x / 10 ) + x % 10;
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <set>
|
||||
#include <ctime>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#define CL(arr, val) memset(arr, val, sizeof(arr))
|
||||
#define REP(i, n) for((i) = 0; (i) < (n); ++(i))
|
||||
#define FOR(i, l, h) for((i) = (l); (i) <= (h); ++(i))
|
||||
#define FORD(i, h, l) for((i) = (h); (i) >= (l); --(i))
|
||||
#define L(x) (x) << 1
|
||||
#define R(x) (x) << 1 | 1
|
||||
#define MID(l, r) (l + r) >> 1
|
||||
#define Min(x, y) x < y ? x : y
|
||||
#define Max(x, y) x < y ? y : x
|
||||
#define E(x) (1 << (x))
|
||||
const double eps = 1e-4;
|
||||
typedef long long LL;
|
||||
const int inf = ~0u>>2;
|
||||
using namespace std;
|
||||
const int N = 110;
|
||||
const int M = 1000010;
|
||||
const int MOD = 1e9 + 7;
|
||||
int c[N][N];
|
||||
int k[M], t[M];
|
||||
int num, n;
|
||||
int prime[N*20];
|
||||
bool vis[N*20];
|
||||
int cnt;
|
||||
void get_prime() {
|
||||
CL(vis, true);
|
||||
int i, j;
|
||||
for(i = 2; i < N*20; ++i) {
|
||||
for(j = i*i; j < N*20; j += i) {
|
||||
vis[j] = false;
|
||||
}
|
||||
}
|
||||
cnt = 0;
|
||||
for(i = 2; i < N*20; ++i) {
|
||||
if(vis[i]) prime[cnt++] = i;
|
||||
}
|
||||
}
|
||||
void init() {
|
||||
get_prime();
|
||||
CL(c, 0);
|
||||
int i , j;
|
||||
for(i = 0; i < N; ++i) c[i][0] = c[i][i] = 1;
|
||||
for(i = 2; i < N; ++i) {
|
||||
for(j = 1; j < i; ++j) {
|
||||
c[i][j] = (c[i-1][j] + c[i-1][j-1])%MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
LL solve(int x) {
|
||||
int m = n, flag = 1, i;
|
||||
for(i = 0; i < n; ++i) {
|
||||
if(((1<<i)&x) == 0) {
|
||||
flag *= -1; m--;
|
||||
}
|
||||
}
|
||||
LL tmp = 1;
|
||||
for(i = 0; i < num; ++i) {
|
||||
tmp = tmp*LL(c[k[i]+m-1][m-1])%MOD;
|
||||
}
|
||||
return tmp*flag;
|
||||
}
|
||||
int main() {
|
||||
init();
|
||||
int x, i, j;
|
||||
LL ans;
|
||||
while(~scanf("%d", &n)) {
|
||||
CL(t, 0);
|
||||
for(i = 0; i < n; ++i) {
|
||||
scanf("%d", &x);
|
||||
for(j = 0; prime[j]*prime[j] <= x; ++j) {
|
||||
if(x%prime[j] == 0) {
|
||||
while(x%prime[j] == 0) {
|
||||
t[prime[j]]++; x /= prime[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
if(x != 1) t[x]++;
|
||||
}
|
||||
num = 0;
|
||||
for(i = 2; i < M; ++i) {
|
||||
if(t[i] != 0) {
|
||||
k[num++] = t[i];
|
||||
}
|
||||
}
|
||||
ans = 0;
|
||||
for(i = (1<<n)-1; i >= 1; --i) {
|
||||
ans = (ans + solve(i))%MOD;
|
||||
}
|
||||
cout << (ans%MOD + MOD)%MOD << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
#define for if(0); else for
|
||||
const int N=65537*2;
|
||||
struct SegTree{
|
||||
int a[N<<1],mi[N<<1],mx[N<<1];
|
||||
int Q;
|
||||
void init(int n,int c[]){
|
||||
for(Q=1;Q<=n+2;Q<<=1);
|
||||
memset(a,0,sizeof(a));
|
||||
for(int i=Q+0;i<Q+n;i++) a[i]=mi[i]=mx[i]=c[i-Q];
|
||||
for(int i=Q-1;i>=1;i--) pushup(i);
|
||||
}
|
||||
void pushup(int rt) {
|
||||
a[rt]=a[rt<<1]==a[rt<<1|1]?a[rt<<1]:-1;
|
||||
mi[rt]=min(mi[rt<<1],mi[rt<<1|1]);
|
||||
mx[rt]=max(mx[rt<<1],mx[rt<<1|1]);
|
||||
}
|
||||
void update_one(int rt,int x) {
|
||||
a[rt]=mi[rt]=mx[rt]=x;
|
||||
}
|
||||
void pushdown(int rt) {
|
||||
if(a[rt]!=-1) {
|
||||
update_one(rt<<1,a[rt]);
|
||||
update_one(rt<<1|1,a[rt]);
|
||||
}
|
||||
}
|
||||
void update(int L,int R,int l,int r,int rt,int c) {
|
||||
if(a[rt]==c) return;
|
||||
if(L<=l && r<=R) {
|
||||
update_one(rt,c);
|
||||
return;
|
||||
}
|
||||
pushdown(rt);
|
||||
if(rt>=Q) return;
|
||||
int m=(l+r)>>1;
|
||||
if(L<=m) update(L,R,l,m,rt<<1,c);
|
||||
if(m<R) update(L,R,m+1,r,rt<<1|1,c);
|
||||
pushup(rt);
|
||||
}
|
||||
int query(int L,int R,int l,int r,int rt,int c) {
|
||||
int ret=0;
|
||||
if(L<=l && r<=R) {
|
||||
if(c>=mi[rt]&&c<=mx[rt]){
|
||||
int m=(l+r)>>1;
|
||||
if(a[rt]!=-1) return (a[rt]==c)?r-l+1:0;
|
||||
else return query(L,R,l,m,rt<<1,c)+query(L,R,m+1,r,rt<<1|1,c);
|
||||
}else return 0;
|
||||
}
|
||||
if(rt>=Q) return ret;
|
||||
pushdown(rt);
|
||||
int m=(l+r)>>1;
|
||||
if(L<=m) ret+=query(L,R,l,m,rt<<1,c);
|
||||
if(m<R) ret+=query(L,R,m+1,r,rt<<1|1,c);
|
||||
return ret;
|
||||
}
|
||||
}st;
|
||||
int a[N];
|
||||
int n,m;
|
||||
int main() {
|
||||
while(scanf("%d%d",&n,&m)!=EOF) {
|
||||
for(int i=0;i<n;i++) scanf("%d",&a[i]);
|
||||
st.init(n,a);
|
||||
for(int i=0;i<m;i++) {
|
||||
int cmd,l,r,c;
|
||||
scanf("%d%d%d%d",&cmd,&l,&r,&c);
|
||||
if(cmd==1){
|
||||
st.update(l,r,0,st.Q-1,1,c);
|
||||
}else {
|
||||
printf("%d\n",st.query(l,r,0,st.Q-1,1,c));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
const double eps=1e-8;
|
||||
int pr[1231];
|
||||
struct A{vector<int> a;double s;}e,te;
|
||||
struct P{int p[100],n;double s;}p,da;
|
||||
long long mx;
|
||||
int pt1(A &e,int n){
|
||||
double k=1;
|
||||
for(int i=0;i<n;i++){
|
||||
k*=pow(pr[i]+0.0,e.a[i]+0.0);
|
||||
if(k>p.s*1.00000001)return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
void cf(P &p,int k){
|
||||
p.p[p.n]=0;
|
||||
for(int i=0;i<p.n;i++)
|
||||
p.p[i]*=k;
|
||||
for(int i=0;i<p.n;i++)
|
||||
p.p[i+1]+=p.p[i]/10,p.p[i]%=10;
|
||||
while(p.p[p.n]){
|
||||
p.p[p.n+1]=p.p[p.n]/10;
|
||||
p.p[p.n]%=10;
|
||||
p.n++;
|
||||
}
|
||||
}
|
||||
P qiu(A &a,int n){
|
||||
P p;
|
||||
p.n=1;
|
||||
p.p[0]=1;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int q=0;q<a.a[i];q++)
|
||||
cf(p,pr[i]);
|
||||
return p;
|
||||
}
|
||||
int pt(P a,P b){
|
||||
if(a.n!=b.n){
|
||||
return a.n<b.n;
|
||||
}
|
||||
for(int i=a.n;i--;){
|
||||
if(a.p[i]!=b.p[i])
|
||||
return a.p[i]<b.p[i];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int s[123],x[123];
|
||||
int n;
|
||||
long long js(A &e,int n){
|
||||
long long da=1;
|
||||
for(int i=0;i<n;i++)
|
||||
da*=e.a[i]+1;
|
||||
return da;
|
||||
}
|
||||
void dfs(int rt,A& e,long long k){
|
||||
if(rt>n)return ;
|
||||
if(k>=mx){
|
||||
if(!pt1(e,rt))return ;
|
||||
if(k>mx||(k==mx&& pt(qiu(e,rt),da))){
|
||||
if(!pt(qiu(e,rt),p))return ;
|
||||
mx=k;
|
||||
da=qiu(e,rt);
|
||||
}
|
||||
}
|
||||
int ss=s[rt];
|
||||
if(rt)ss=min(ss,e.a[rt-1]);
|
||||
for(int i=ss;i>=x[rt];i--){
|
||||
e.a[rt]=i;
|
||||
dfs(rt+1,e,k*(e.a[rt]+1));
|
||||
}
|
||||
}
|
||||
int gs(int k){ return 2*(log(pr[n]+0.0)/log(k+0.0))-1;}
|
||||
int gx(int k){ return (log(pr[n]+0.0)/log(k+0.0));}
|
||||
void qiu(){
|
||||
for(n=1;;n++){
|
||||
e.a.clear();
|
||||
for(int i=0;i<n;i++)
|
||||
s[i]=gs(pr[i]),x[i]=gx(pr[i]);
|
||||
if(x[0]<3)x[0]=1;
|
||||
for(int i=0;i<n;i++)
|
||||
e.a.push_back(1);
|
||||
if(!pt1(e,n))break;
|
||||
}
|
||||
if(n<15)
|
||||
for(int i=0;i<n;i++)
|
||||
x[i]=1;
|
||||
e.a.clear();
|
||||
for(int i=0;i<n;i++)e.a.push_back(0);
|
||||
dfs(0,e,1);
|
||||
}
|
||||
int main(){
|
||||
int ind=0;
|
||||
for(int i=2;i<1e3;i++){
|
||||
if(pr[i]==0){
|
||||
pr[ind++]=i;
|
||||
for(int q=i*i;q<1e3;q+=i)
|
||||
pr[q]=1;
|
||||
}
|
||||
}
|
||||
string s;
|
||||
while(cin>>s){
|
||||
if(s=="1"){
|
||||
puts("1 1");
|
||||
continue;
|
||||
}
|
||||
mx=-1;
|
||||
reverse(s.begin(),s.end());
|
||||
p.n=s.size();
|
||||
p.s=0;
|
||||
for(int i=0;i<s.size();i++){
|
||||
p.p[i]=s[i]-'0';
|
||||
p.s+=p.p[i]*pow(10.0,i);
|
||||
}
|
||||
qiu();
|
||||
p=da;
|
||||
for(int i=p.n;i--;)
|
||||
cout<<p.p[i];
|
||||
cout<<' '<<mx;cout<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#define Min(a,b) a<b?a:b
|
||||
#define Max(a,b) a>b?a:b
|
||||
#define CL(a,num) memset(a,num,sizeof(a));
|
||||
#define maxn 60100
|
||||
#define eps 1e-6
|
||||
#define inf 9999999
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int f;
|
||||
int s;
|
||||
int id;
|
||||
}p[maxn] ;
|
||||
int vis[maxn];
|
||||
int cmp(const node a,const node b)
|
||||
{
|
||||
if( a.s != b.s) return a.s > b.s;
|
||||
else
|
||||
if(a.f != b.f) return a.f > b.f ;
|
||||
else
|
||||
return a.id < b.id;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,j,n,k,cnt;
|
||||
int cas = 0 ;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
int mx = -1;
|
||||
scanf("%d",&n);
|
||||
for(i = 1;i <=n;i++ )
|
||||
{
|
||||
scanf("%d%d",&p[i].f,&p[i].s);
|
||||
p[i].id = i;
|
||||
if(mx < p[i].f)
|
||||
{
|
||||
mx = p[i].f ;
|
||||
k = i;
|
||||
}
|
||||
}
|
||||
printf("Case #%d:\n",++cas);
|
||||
printf("%d",k);
|
||||
vis[k] = 1 ;
|
||||
if(n > 510)cnt = 510;
|
||||
else cnt = n;
|
||||
for(i = 1;i <= cnt - 1;i++)
|
||||
{
|
||||
mx = -1;
|
||||
for(j = 1;j <= n;j++)
|
||||
{
|
||||
if(!vis[j])
|
||||
{
|
||||
p[j].f +=p[j].s;
|
||||
if(mx < p[j].f)
|
||||
{
|
||||
k = j;
|
||||
mx = p[j].f;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf(" %d",k);
|
||||
vis[k] = 1;
|
||||
}
|
||||
if(cnt < n)
|
||||
{
|
||||
sort(p + 1,p+1+n,cmp);
|
||||
for(i = 1; i <= n;i++)
|
||||
{
|
||||
if(!vis[p[i].id])
|
||||
{
|
||||
printf(" %d",p[i].id);
|
||||
vis[p[i].id] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include<stdio.h>
|
||||
__int64 T,n,tag;
|
||||
__int64 ans,mod[11]={0,1},dig[11];
|
||||
__int64 i,j,k,t;
|
||||
struct node
|
||||
{
|
||||
__int64 id,val;
|
||||
}que[100000001];
|
||||
__int64 wei(__int64 x)
|
||||
{
|
||||
__int64 z=1;
|
||||
if(!x) return 0;
|
||||
while(x/=10) z++;
|
||||
return z;
|
||||
}
|
||||
__int64 cmp(__int64 a, __int64 b, __int64 k)
|
||||
{
|
||||
while(k--)
|
||||
{
|
||||
if(a%10!=b%10) return 0;
|
||||
a/=10;b/=10;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
__int64 bfs(__int64 x)
|
||||
{
|
||||
__int64 t=0,pop=0,push=1,i,j,bl,ans,sw,k=0;
|
||||
que[0].id=que[0].val=0;ans=sw=0x7fffffff;
|
||||
while(pop<push)
|
||||
{
|
||||
t=que[pop].val;
|
||||
k=que[pop++].id+1;
|
||||
if(cmp(t*t,x,wei(x)))
|
||||
{
|
||||
ans=t<ans?t:ans;
|
||||
sw=wei(ans);
|
||||
}
|
||||
if(wei(t)>=wei(x)) return 0;
|
||||
if(k>sw) continue;
|
||||
for(i=0;i<10;i++)
|
||||
{
|
||||
if(cmp((i*mod[k]+t)*(i*mod[k]+t),x%mod[k+1],k))
|
||||
{
|
||||
if(cmp((i*mod[k]+t)*(i*mod[k]+t),x,wei(x)))
|
||||
{
|
||||
ans=(i*mod[k]+t)<ans?(i*mod[k]+t):ans;
|
||||
sw=wei(ans);
|
||||
continue;
|
||||
}
|
||||
if(k>=sw) continue;
|
||||
que[push].val=i*mod[k]+t;
|
||||
que[push++].id=k;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ans==0x7fffffff) return 0;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%I64d",&T);
|
||||
for(i=2;i<=10;i++) mod[i]=mod[i-1]*10;
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d",&tag);
|
||||
ans=bfs(tag);
|
||||
if(ans) printf("%I64d\n",ans);
|
||||
else printf("None\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 2e5 + 2e4;
|
||||
const int shift = 2e5;
|
||||
bool reach[N];
|
||||
int w[205];
|
||||
inline int read(){
|
||||
double x;
|
||||
scanf("%lf",&x);
|
||||
if(x > 0)
|
||||
return x * 10000 + 1e-8;
|
||||
else
|
||||
return x * 10000 - 1e-8;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,n;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
memset(reach,false,sizeof(reach));
|
||||
int goal = read();
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
w[i] = read();
|
||||
sort(w,w+n);
|
||||
reach[ 0 + shift ] = true;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
bool f = w[i] > 0;
|
||||
if(f)
|
||||
{
|
||||
for(int j=N-1-w[i];j>=0;j--)
|
||||
if(reach[j])
|
||||
reach[ j + w[i] ] = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int j=-w[i];j<N;j++)
|
||||
if(reach[j])
|
||||
reach[ j + w[i] ] = true;
|
||||
}
|
||||
}
|
||||
int i = goal + shift , j = 0;
|
||||
int ans = -1;
|
||||
while(1)
|
||||
{
|
||||
if(i-j >= 0 && reach[i-j])
|
||||
{
|
||||
ans = i - j;
|
||||
break;
|
||||
}
|
||||
if(i+j < N && reach[i+j])
|
||||
{
|
||||
ans = i + j;
|
||||
break;
|
||||
}
|
||||
++j;
|
||||
}
|
||||
printf("%.4f\n",(ans-shift)/10000.0);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int N = 5005;
|
||||
const int M = 200005;
|
||||
const int NN = 505;
|
||||
const int Lum = 10;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
int vis[N][NN], d[N][NN], en;
|
||||
int head[M];
|
||||
int n, m, s, t, k;
|
||||
struct node {
|
||||
int to, dis, next;
|
||||
}edge[M];
|
||||
void addEdge(int u,int v,int x) {
|
||||
edge[en].to = v;
|
||||
edge[en].next = head[u];
|
||||
edge[en].dis = x;
|
||||
head[u] = en++;
|
||||
edge[en].to = u;
|
||||
edge[en].next = head[v];
|
||||
edge[en].dis = x;
|
||||
head[v] = en++;
|
||||
}
|
||||
struct Node{
|
||||
int u, m;
|
||||
};
|
||||
void SPFA() {
|
||||
queue<Node> Q;
|
||||
for(int i = 1; i <= n; i++) {
|
||||
for (int j = 0; j <= NN; j++) {
|
||||
d[i][j] = INF;
|
||||
vis[i][j] = 0;
|
||||
}
|
||||
}
|
||||
d[s][0] = 0;
|
||||
vis[s][0] = 1;
|
||||
Q.push((Node){s, 0});
|
||||
while(!Q.empty()) {
|
||||
int u = Q.front().u;
|
||||
int m = Q.front().m;
|
||||
vis[u][m] = 0;
|
||||
Q.pop();
|
||||
int temp = m + Lum;
|
||||
if (temp >= NN) continue;
|
||||
if (temp > k) temp = k;
|
||||
for(int i = head[u]; i != -1; i = edge[i].next) {
|
||||
int v = edge[i].to;
|
||||
if(d[u][m] + edge[i].dis < d[v][temp]) {
|
||||
d[v][temp] = d[u][m] + edge[i].dis;
|
||||
if(!vis[v][temp]) {
|
||||
Q.push((Node){v, temp});
|
||||
vis[v][temp] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void input() {
|
||||
int u, v, c;
|
||||
for (int i = 0; i < m; i++) {
|
||||
scanf("%d %d %d", &u, &v, &c);
|
||||
addEdge(u, v, c);
|
||||
}
|
||||
scanf("%d %d %d", &s, &t, &k);
|
||||
}
|
||||
int main() {
|
||||
while (scanf("%d %d", &n, &m) == 2) {
|
||||
en = 0;
|
||||
memset(head, -1, sizeof(head));
|
||||
input();
|
||||
if (k % 10) {
|
||||
k = 10 * ((k / 10) + 1);
|
||||
}
|
||||
SPFA();
|
||||
if (d[t][k] == INF) {
|
||||
printf("-1\n");
|
||||
} else printf("%d\n", d[t][k]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
struct node{
|
||||
int a[59];
|
||||
void init()
|
||||
{
|
||||
for(int i=0;i<59;i++) a[i]=i;
|
||||
}
|
||||
void chface(int a0,int a1,int a2,int a3,int a4,int a5,int a6,int a7,int a8)
|
||||
{
|
||||
int tmp= a[a0];
|
||||
a[a0]=a[a6],a[a6]=a[a8],a[a8]=a[a2],a[a2]=tmp;
|
||||
tmp = a[a1];
|
||||
a[a1]=a[a3],a[a3]=a[a7],a[a7]=a[a5],a[a5]=tmp;
|
||||
}
|
||||
void chline(int a0,int a1,int a2,int a3,int a4,int a5,int a6,int a7,int a8,int a9,int a10,int a11)
|
||||
{
|
||||
int tmp = a[a0];
|
||||
a[a0]=a[a9],a[a9]=a[a6],a[a6]=a[a3],a[a3]=tmp;
|
||||
tmp = a[a1];
|
||||
a[a1]=a[a10],a[a10]=a[a7],a[a7]=a[a4],a[a4]=tmp;
|
||||
tmp = a[a2];
|
||||
a[a2]=a[a11],a[a11]=a[a8],a[a8]=a[a5],a[a5]=tmp;
|
||||
}
|
||||
bool check()
|
||||
{
|
||||
for(int i=0;i<59;i++)
|
||||
if(a[i]!=i) return false;
|
||||
return true;
|
||||
}
|
||||
void U()
|
||||
{
|
||||
chface(36,37,38, 39,40,41, 42,43,44);
|
||||
chline(2,1,0, 29,28,27, 20,19,18 ,11,10,9);
|
||||
}
|
||||
void u()
|
||||
{
|
||||
chface(38,37,36, 41,40,39, 44,43,42);
|
||||
chline(9,10,11,18,19,20,27,28,29,0,1,2);
|
||||
}
|
||||
void R()
|
||||
{
|
||||
chface(9,10,11,12,13,14,15,16,17);
|
||||
chline(44,41,38,18,21,24,53,50,47,8,5,2);
|
||||
}
|
||||
void r()
|
||||
{
|
||||
chface(11,10,9, 14,13,12, 17,16,15);
|
||||
chline(2,5,8,47,50,53,24,21,18,38,41,44);
|
||||
}
|
||||
void F()
|
||||
{
|
||||
chface(0,1,2,3,4,5,6,7,8);
|
||||
chline(42,43,44 ,9,12,15, 47,46,45, 35,32,29);
|
||||
}
|
||||
void f()
|
||||
{
|
||||
chface(2,1,0, 5,4,3, 8,7,6);
|
||||
chline(29,32,35,45,46,47,15,12,9,44,43,42);
|
||||
}
|
||||
void D()
|
||||
{
|
||||
chface(45,46,47,48,49,50,51,52,53);
|
||||
chline(6,7,8 ,15,16,17, 24,25,26, 33,34,35);
|
||||
}
|
||||
void d()
|
||||
{
|
||||
chface(47,46,45, 50,49,48, 53,52,51);
|
||||
chline(35,34,33,26,25,24,17,16,15,8,7,6);
|
||||
}
|
||||
void L()
|
||||
{
|
||||
chface(27,28,29,30,31,32,33,34,35);
|
||||
chline(0,3,6, 45,48,51, 26,23,20, 36,39,42);
|
||||
}
|
||||
void l()
|
||||
{
|
||||
chface(29,28,27,32,31,30,35,34,33);
|
||||
chline(42,39,36,20,23,26,51,48,45,6,3,0);
|
||||
}
|
||||
void B()
|
||||
{
|
||||
chface(18,19,20,21,22,23,24,25,26);
|
||||
chline(38,37,36, 27,30,33, 51,52,53, 17,14,11);
|
||||
}
|
||||
void b()
|
||||
{
|
||||
chface(20,19,18, 23,22,21,26,25,24);
|
||||
chline(11,14,17,53,52,51,33,30,27,36,37,38);
|
||||
}
|
||||
void X()
|
||||
{
|
||||
chline(5,4,3, 32,31,30, 23,22,21, 14,13,12);
|
||||
}
|
||||
void x()
|
||||
{
|
||||
chline(12,13,14,21,22,23,30,31,32,3,4,5);
|
||||
}
|
||||
void Y()
|
||||
{
|
||||
chline(7,4,1, 43,40,37, 19,22,25, 52,49,46);
|
||||
}
|
||||
void y()
|
||||
{
|
||||
chline(46,49,52,25,22,19,37,40,43,1,4,7);
|
||||
}
|
||||
void Z()
|
||||
{
|
||||
chline(41,40,39,28,31,34, 48,49,50, 16,13,10);
|
||||
}
|
||||
void z()
|
||||
{
|
||||
chline(10,13,16,50,49,48,34,31,28,39,40,41);
|
||||
}
|
||||
};
|
||||
int main()
|
||||
{
|
||||
char a[2009];
|
||||
node t;
|
||||
bool ou = false;
|
||||
while(~scanf("%s",a))
|
||||
{
|
||||
if(ou) printf("\n");
|
||||
ou = true;
|
||||
t.init();
|
||||
int len = strlen(a);
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
if(a[i]=='U') t.U();
|
||||
else if(a[i]=='R') t.R();
|
||||
else if(a[i]=='F') t.F();
|
||||
else if(a[i]=='D') t.D();
|
||||
else if(a[i]=='L') t.L();
|
||||
else if(a[i]=='B') t.B();
|
||||
else if(a[i]=='X') t.X();
|
||||
else if(a[i]=='Y') t.Y();
|
||||
else if(a[i]=='Z') t.Z();
|
||||
else if(a[i]=='u') t.u();
|
||||
else if(a[i]=='r') t.r();
|
||||
else if(a[i]=='f') t.f();
|
||||
else if(a[i]=='d') t.d();
|
||||
else if(a[i]=='l') t.l();
|
||||
else if(a[i]=='b') t.b();
|
||||
else if(a[i]=='x') t.x();
|
||||
else if(a[i]=='y') t.y();
|
||||
else if(a[i]=='z') t.z();
|
||||
}
|
||||
if(t.check())
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#include<map>
|
||||
#include<set>
|
||||
using namespace std;
|
||||
const int MAXN=100010;
|
||||
int Ti[MAXN];
|
||||
int ne[MAXN];
|
||||
map<int,int>mp;
|
||||
struct Node
|
||||
{
|
||||
int next_id;
|
||||
int ti;
|
||||
};
|
||||
struct classcomp
|
||||
{
|
||||
bool operator()(const Node &a,const Node &b)const
|
||||
{
|
||||
return a.next_id<b.next_id;
|
||||
}
|
||||
};
|
||||
multiset<Node,classcomp>T_info;
|
||||
multiset<Node>::iterator it_n;
|
||||
set<int>Te;
|
||||
set<int>::iterator it;
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&Ti[i]);
|
||||
mp.clear();
|
||||
for(int i=n;i>=1;i--)
|
||||
{
|
||||
if(mp[Ti[i]])
|
||||
ne[i]=mp[Ti[i]];
|
||||
else ne[i]=n+1;
|
||||
mp[Ti[i]]=i;
|
||||
}
|
||||
Te.clear();
|
||||
T_info.clear();
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
if(!mp[i])mp[i]=n+1;
|
||||
Node temp;
|
||||
temp.next_id=mp[i];
|
||||
temp.ti=i;
|
||||
T_info.insert(temp);
|
||||
Te.insert(i);
|
||||
}
|
||||
int ans=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
it=Te.find(Ti[i]);
|
||||
if(it!=Te.end())
|
||||
{
|
||||
Node temp;
|
||||
temp.next_id=i;
|
||||
temp.ti=Ti[i];
|
||||
T_info.erase(temp);
|
||||
temp.next_id=ne[i];
|
||||
T_info.insert(temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
ans++;
|
||||
it_n=T_info.end();
|
||||
it_n--;
|
||||
if(ne[i]<(*it_n).next_id)
|
||||
{
|
||||
Te.erase((*it_n).ti);
|
||||
T_info.erase(it_n);
|
||||
Te.insert(Ti[i]);
|
||||
Node temp;
|
||||
temp.next_id=ne[i];
|
||||
temp.ti=Ti[i];
|
||||
T_info.insert(temp);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue