KiritoTRw
GitHub
parent
1d53c6ce3d
commit
37c7dfef72
|
|
@ -0,0 +1,177 @@
|
|||
#include <stdio.h>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
#define N 8005
|
||||
#define EPS 1e-8
|
||||
struct TPoint {
|
||||
int x, y;
|
||||
TPoint() {
|
||||
}
|
||||
TPoint(const int &_x, const int &_y) :
|
||||
x(_x), y(_y) {
|
||||
}
|
||||
bool operator ==(const TPoint &b) const {
|
||||
return (x == b.x && y == b.y);
|
||||
}
|
||||
TPoint operator-(const TPoint &b) const {
|
||||
return TPoint(x - b.x, y - b.y);
|
||||
}
|
||||
};
|
||||
TPoint p[N], hull[N],r;
|
||||
int tn;
|
||||
double cross(const TPoint & a, const TPoint & b, const TPoint & c) {
|
||||
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
|
||||
}
|
||||
double len(const TPoint &a) {
|
||||
return sqrt((double) (a.x * a.x + a.y * a.y));
|
||||
}
|
||||
double dis(const TPoint &a, const TPoint &b) {
|
||||
return len(b - a);
|
||||
}
|
||||
bool graham_cmp(const TPoint &b, const TPoint &c) {
|
||||
double tmp = cross(b, c, p[0]);
|
||||
if (tmp > EPS)
|
||||
return true;
|
||||
if (fabs(tmp) < EPS && (dis(b, p[0]) < dis(c, p[0])))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
int graham_scan(int n) {
|
||||
int top, i, k = 0;
|
||||
for (i = 1; i < n; ++i) {
|
||||
if ((p[k].y - p[i].y < EPS) || (fabs((double)p[i].y - p[k].y) < EPS && p[k].x
|
||||
- p[i].x > EPS))
|
||||
k = i;
|
||||
}
|
||||
swap(p[0], p[k]);
|
||||
sort(p + 1, p + n, graham_cmp);
|
||||
hull[0] = p[0], hull[1] = p[1], hull[2] = p[2];
|
||||
if (n < 3)
|
||||
return n;
|
||||
else
|
||||
top = 3;
|
||||
for (i = 3; i < n; ++i) {
|
||||
while (top >= 2 && cross(hull[top - 2], hull[top - 1], p[i]) < EPS)
|
||||
--top;
|
||||
hull[top++] = p[i];
|
||||
}
|
||||
return top;
|
||||
}
|
||||
inline double dis_p2_line(TPoint & a,TPoint & b,TPoint & p)
|
||||
{ return fabs(cross(a,p,b))/dis(a,b); }
|
||||
struct node {
|
||||
int x1, x2, y1, y2;
|
||||
int level;
|
||||
bool flag;
|
||||
} a[2005];
|
||||
int Max(int a, int b) {
|
||||
return a > b ? a : b;
|
||||
}
|
||||
int Min(int a, int b) {
|
||||
return a < b ? a : b;
|
||||
}
|
||||
int main() {
|
||||
int i, j, n;
|
||||
int level, t, x, y;
|
||||
while (scanf("%d", &n) != EOF) {
|
||||
for (i = 0; i < n; ++i) {
|
||||
scanf("%d%d%d%d", &a[i].x1, &a[i].y1, &a[i].x2, &a[i].y2);
|
||||
a[i].flag = false;
|
||||
a[i].x1 *= 2;
|
||||
a[i].y1 *= 2;
|
||||
a[i].x2 *= 2;
|
||||
a[i].y2 *= 2;
|
||||
if (a[i].x1 > a[i].x2) {
|
||||
t = a[i].x1;
|
||||
a[i].x1 = a[i].x2;
|
||||
a[i].x2 = t;
|
||||
}
|
||||
if (a[i].y1 > a[i].y2) {
|
||||
t = a[i].y1;
|
||||
a[i].y1 = a[i].y2;
|
||||
a[i].y2 = t;
|
||||
}
|
||||
}
|
||||
a[0].level = 1;
|
||||
a[0].flag = true;
|
||||
for (i = 1; i < n; ++i) {
|
||||
level = 1;
|
||||
for (j = i-1; j >= 0; --j) {
|
||||
if (level >= a[j].level + 1)
|
||||
continue;
|
||||
if (a[i].x2 <= a[j].x1)
|
||||
continue;
|
||||
if (a[j].x2 <= a[i].x1)
|
||||
continue;
|
||||
if (a[i].y2 <= a[j].y1)
|
||||
continue;
|
||||
if (a[j].y2 <= a[i].y1)
|
||||
continue;
|
||||
level = a[j].level + 1;
|
||||
}
|
||||
a[i].level = level;
|
||||
tn = 0;
|
||||
for (j = 0; j < i; ++j) {
|
||||
if (level != a[j].level + 1)
|
||||
continue;
|
||||
if (a[i].x2 <= a[j].x1)
|
||||
continue;
|
||||
if (a[j].x2 <= a[i].x1)
|
||||
continue;
|
||||
if (a[i].y2 <= a[j].y1)
|
||||
continue;
|
||||
if (a[j].y2 <= a[i].y1)
|
||||
continue;
|
||||
int x1,x2,y1,y2;
|
||||
x1 = Max(a[i].x1,a[j].x1);
|
||||
x2 = Min(a[i].x2,a[j].x2);
|
||||
y1 = Max(a[i].y1,a[j].y1);
|
||||
y2 = Min(a[i].y2,a[j].y2);
|
||||
p[tn].x = x1;
|
||||
p[tn++].y = y1;
|
||||
p[tn].x = x1;
|
||||
p[tn++].y = y2;
|
||||
p[tn].x = x2;
|
||||
p[tn++].y = y1;
|
||||
p[tn].x = x2;
|
||||
p[tn++].y = y2;
|
||||
}
|
||||
if(tn==0)
|
||||
{
|
||||
a[i].flag=true;
|
||||
continue;
|
||||
}
|
||||
p[tn].x=((a[i].x1+a[i].x2)>>1);
|
||||
p[tn++].y=((a[i].y1+a[i].y2)>>1);
|
||||
tn=graham_scan(tn);
|
||||
a[i].flag=true;
|
||||
for(j=0;j<tn;++j)
|
||||
{
|
||||
if(hull[j]==TPoint(((a[i].x1+a[i].x2)>>1),((a[i].y1+a[i].y2)>>1)))
|
||||
{
|
||||
a[i].flag=false;
|
||||
a[i].level=-1;
|
||||
break;
|
||||
}
|
||||
r=TPoint(((a[i].x1+a[i].x2)>>1),((a[i].y1+a[i].y2)>>1));
|
||||
double s=fabs(dis_p2_line(hull[j],hull[(j+1)%tn],r));
|
||||
if(s<EPS)
|
||||
{
|
||||
a[i].flag=false;
|
||||
a[i].level=-1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for(i=0;i<n;++i)
|
||||
{
|
||||
if(a[i].flag)
|
||||
ans++;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include<stdlib.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
int a,b;
|
||||
double c,d,t,pi;
|
||||
bool flag;
|
||||
int main()
|
||||
{
|
||||
pi = 3.1416926536;
|
||||
while(scanf("%d%d%lf",&a,&b,&c)!=EOF && (a!=0 || b !=0 || fabs(c)>0.0000001))
|
||||
{
|
||||
printf("%d\n",a - 1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int a[1005],sum[1005];
|
||||
int main()
|
||||
{
|
||||
int n,i;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
memset(sum,0,sizeof(sum));
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
sort(a+1,a+1+n);
|
||||
for(i=1;i<=n;i++)
|
||||
sum[i]=sum[i-1]+a[i];
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(a[i]>sum[i-1]+1)
|
||||
break;
|
||||
}
|
||||
printf("%d\n",sum[i-1]+1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
char a[5000];
|
||||
int main()
|
||||
{
|
||||
int i,j,k,n,m,b,c;
|
||||
while (1)
|
||||
{
|
||||
if (scanf("%d",&n)==EOF) break;
|
||||
scanf("%s",a);
|
||||
for (i=0;i<n;i++) a[i]-='0';
|
||||
bool f=false;
|
||||
int ans=0;
|
||||
b=0;
|
||||
c=10;
|
||||
for (i=0;i<n;i++)
|
||||
{
|
||||
if (f==false)
|
||||
{
|
||||
if (c>a[i]) b=a[i];
|
||||
else
|
||||
{
|
||||
i++;
|
||||
b=a[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (a[i]>b) c=a[i];
|
||||
else
|
||||
{
|
||||
if (a[i]==0)
|
||||
{
|
||||
while (a[i]==0) i++;
|
||||
b=0;
|
||||
c=a[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
i++;
|
||||
c=a[i-1]*10+a[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (i>=n) break;
|
||||
ans++;f=!f;
|
||||
}
|
||||
cout<<ans-1<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#include<cstdio>
|
||||
#include<stdlib.h>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int inf=99999999;
|
||||
struct{
|
||||
int v, cap, cost, next, re;
|
||||
}edge[10005];
|
||||
int n,ans;
|
||||
int k,edgeHead[1050];
|
||||
int que[10050],pre[1050],dis[1050];
|
||||
bool vis[1050];
|
||||
int wei[1050];
|
||||
int min(int a,int b){
|
||||
return a>b?b:a;
|
||||
}
|
||||
int max(int a,int b){
|
||||
return a>b?a:b;
|
||||
}
|
||||
void addEdge(int u,int v,int ca,int co){
|
||||
edge[k].v=v;
|
||||
edge[k].cap=ca;
|
||||
edge[k].cost=co;
|
||||
edge[k].next=edgeHead[u];
|
||||
edge[k].re=k + 1;
|
||||
edgeHead[u]=k ++;
|
||||
edge[k].v=u;
|
||||
edge[k].cap=0;
|
||||
edge[k].cost=-co;
|
||||
edge[k].next=edgeHead[v];
|
||||
edge[k].re=k - 1;
|
||||
edgeHead[v]=k ++;
|
||||
}
|
||||
bool spfa(){
|
||||
int i, head = 0, tail = 1;
|
||||
for(i = 0; i <= n; i ++){
|
||||
dis[i] = inf;
|
||||
vis[i] = false;
|
||||
}
|
||||
dis[0] = 0;
|
||||
que[0] = 0;
|
||||
vis[0] = true;
|
||||
while(head != tail){
|
||||
int u = que[head];
|
||||
for(i = edgeHead[u]; i != 0; i = edge[i].next){
|
||||
int v = edge[i].v;
|
||||
if(edge[i].cap && dis[v] >dis[u] + edge[i].cost){
|
||||
dis[v] = dis[u] + edge[i].cost;
|
||||
pre[v] = i;
|
||||
if(!vis[v]){
|
||||
vis[v] = true;
|
||||
que[tail ++] = v;
|
||||
if(tail == 10000) tail = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
vis[u] = false;
|
||||
head++;
|
||||
if(head ==10000) head = 0;
|
||||
}
|
||||
if(dis[n] ==inf) return false;
|
||||
return true;
|
||||
}
|
||||
void end(){
|
||||
int u, p;
|
||||
for(u = n; u != 0; u = edge[edge[p].re].v){
|
||||
p = pre[u];
|
||||
edge[p].cap -= 1;
|
||||
edge[edge[p].re].cap += 1;
|
||||
ans += edge[p].cost;
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int i,j,v,lim,m,sum;
|
||||
while(scanf("%d %d %d",&v,&m,&lim)!=EOF){
|
||||
k=1;
|
||||
sum=0;
|
||||
memset(edgeHead,0,sizeof(edgeHead));
|
||||
for(i=1;i<=v;i++){
|
||||
scanf("%d",&wei[i]);
|
||||
sum+=wei[i];
|
||||
}
|
||||
if(m<=lim){
|
||||
printf("%d\n",sum);
|
||||
continue;
|
||||
}
|
||||
n=v-m+2;
|
||||
for(i=0;i<=n;i++){
|
||||
addEdge(i,i+1,lim,0);
|
||||
}
|
||||
for(i=1;i<=v;i++){
|
||||
addEdge(max(1,i-m+1),min(n-1,i)+1,1,-wei[i]);
|
||||
}
|
||||
ans=0;
|
||||
n++;
|
||||
while(spfa())
|
||||
end();
|
||||
printf("%d\n",-ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<cstdio>
|
||||
#define N 200005
|
||||
struct cam
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
int min;
|
||||
int max;
|
||||
int v;
|
||||
}list[N*4];
|
||||
int n,m,p;
|
||||
int Min(int x,int y)
|
||||
{
|
||||
return x<y?x:y;
|
||||
}
|
||||
int Max(int x,int y)
|
||||
{
|
||||
return x>y?x:y;
|
||||
}
|
||||
void build(int k,int x,int y)
|
||||
{
|
||||
list[k].x=x;
|
||||
list[k].y=y;
|
||||
list[k].min=list[k].max=list[k].v=0;
|
||||
if(x==y)
|
||||
return;
|
||||
int mid=(x+y)/2;
|
||||
build(k<<1,x,mid);
|
||||
build(k<<1|1,mid+1,y);
|
||||
}
|
||||
void lazy(int k)
|
||||
{
|
||||
int v=list[k].v;
|
||||
if(v>0)
|
||||
{
|
||||
list[k<<1].v+=v;
|
||||
list[k<<1].min+=v;
|
||||
list[k<<1].max+=v;
|
||||
list[k<<1|1].v+=v;
|
||||
list[k<<1|1].min+=v;
|
||||
list[k<<1|1].max+=v;
|
||||
list[k].v=0;
|
||||
}
|
||||
}
|
||||
void update(int k,int a,int b,int c)
|
||||
{
|
||||
if(list[k].x==a&&list[k].y==b&&(list[k].min>=p||list[k].max<p))
|
||||
{
|
||||
if(list[k].max<p)
|
||||
{
|
||||
list[k].v+=c;
|
||||
list[k].max+=c;
|
||||
list[k].min+=c;
|
||||
}
|
||||
else
|
||||
{
|
||||
list[k].v+=c*2;
|
||||
list[k].max+=c*2;
|
||||
list[k].min+=c*2;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(list[k].v>0)
|
||||
lazy(k);
|
||||
int mid=(list[k].x+list[k].y)/2;
|
||||
if(a>mid)
|
||||
update(k<<1|1,a,b,c);
|
||||
else if(b<=mid)
|
||||
update(k<<1,a,b,c);
|
||||
else
|
||||
{
|
||||
update(k<<1,a,mid,c);
|
||||
update(k<<1|1,mid+1,b,c);
|
||||
}
|
||||
list[k].max=Max(list[k<<1].max,list[k<<1|1].max);
|
||||
list[k].min=Min(list[k<<1].min,list[k<<1|1].min);
|
||||
}
|
||||
int query(int k,int id)
|
||||
{
|
||||
if(list[k].x==id&&list[k].y==id)
|
||||
return list[k].v;
|
||||
if(list[k].v>0)
|
||||
lazy(k);
|
||||
int mid=(list[k].x+list[k].y)/2;
|
||||
if(id<=mid)
|
||||
return query(k<<1,id);
|
||||
else
|
||||
return query(k<<1|1,id);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,a,b,c;
|
||||
while(scanf("%d%d%d",&n,&m,&p)!=EOF)
|
||||
{
|
||||
build(1,1,n);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
update(1,a,b,c);
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(i==n)
|
||||
printf("%d\n",query(1,i));
|
||||
else
|
||||
printf("%d ",query(1,i));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int y,t;
|
||||
}edge[10009];
|
||||
int T[1009];
|
||||
vector<node> v[1009]; int n,m;
|
||||
int in[1009];
|
||||
void solve()
|
||||
{
|
||||
queue<int> q;
|
||||
for(int i=0;i<n;i++)
|
||||
if(in[i]==0)
|
||||
{
|
||||
q.push(i);
|
||||
T[i]=1;
|
||||
}
|
||||
while(!q.empty())
|
||||
{
|
||||
int x=q.front();q.pop();
|
||||
for(int i=0;i<v[x].size();i++)
|
||||
{
|
||||
int y=v[x][i].y;
|
||||
T[y]=max(T[y],T[x]+v[x][i].t);
|
||||
in[y]--;
|
||||
if(in[y]==0)
|
||||
{
|
||||
q.push(y);
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for(int i=0;i<n;i++)
|
||||
ans=max(ans,T[i]);
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a,b,t;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
memset(in,0,sizeof(in));
|
||||
memset(T,0,sizeof(T));
|
||||
for(int i=0;i<n;i++)
|
||||
v[i].clear();
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d%d%d",&a,&edge[i].y,&edge[i].t);
|
||||
v[a].push_back(edge[i]);
|
||||
in[edge[i].y]++;
|
||||
}
|
||||
solve();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int dp[55][55000];
|
||||
int a[55];
|
||||
int DP(int a,int b)
|
||||
{
|
||||
if(dp[a][b]!=-1) return dp[a][b];
|
||||
if(b==1) return dp[a][b]=DP(a+1,0);
|
||||
dp[a][b]=0;
|
||||
if(a>=1&&!DP(a-1,b))
|
||||
dp[a][b]=1;
|
||||
if(a>=1&&b&&!DP(a-1,b+1))
|
||||
dp[a][b]=1;
|
||||
if(a>=2&&((b&&!DP(a-2,b+3))||(b==0&&!DP(a-2,2))))
|
||||
dp[a][b]=1;
|
||||
if(b>=2&&!DP(a,b-1))
|
||||
dp[a][b]=1;
|
||||
return dp[a][b];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
memset(dp,-1,sizeof(dp));
|
||||
int t,test=1,n,i,j,k;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(j=0,k=0,i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
if(a[i]==1) j++;
|
||||
else k+=a[i]+1;
|
||||
}
|
||||
if(k) k--;
|
||||
DP(j,k);
|
||||
printf("Case #%d: ",test++);
|
||||
if(dp[j][k]) printf("Alice\n");
|
||||
else printf("Bob\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int iCase=0;
|
||||
int n,m,k;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d%d",&n,&m,&k);
|
||||
int t1=n,t2,t3=n;
|
||||
if(m<t1)t1=m;
|
||||
if(k<t1)t1=k;
|
||||
if(m>t3)t3=m;
|
||||
if(k>t3)t3=k;
|
||||
t2=n+m+k-t1-t3;
|
||||
n=t1;m=t2;k=t3;
|
||||
int res=0;
|
||||
if(n>1)res+=(int)(log(1.0*n)/log(2.0)+0.999);
|
||||
if(m>1)res+=(int)(log(1.0*m)/log(2.0)+0.999);
|
||||
if(k>1)res+=(int)(log(1.0*k)/log(2.0)+0.999);
|
||||
long long res1=(long long)n*m*k-1;
|
||||
printf("Case #%d: %I64d %d\n",iCase,res1,res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
#define INF 0x3f3f3f3f
|
||||
typedef long long LL;
|
||||
const int N=55;
|
||||
int adj[N][N];
|
||||
int pos[N],T[N],FT[N],pass[N];
|
||||
int dis[N][1<<8][1<<8];
|
||||
int n,m,K;
|
||||
void floyed()
|
||||
{
|
||||
for(int k=1;k<=n;k++)
|
||||
{
|
||||
for(int i=1;i<=n;i++) if(i!=k)
|
||||
{
|
||||
for(int j=1;j<=n;j++) if(j!=i&&j!=k)
|
||||
{
|
||||
adj[i][j]=min(adj[i][j],adj[i][k]+adj[k][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int fun()
|
||||
{
|
||||
int ans=INF;
|
||||
dis[1][0][0]=0;
|
||||
for(int s1=0;s1<(1<<K);s1++)
|
||||
{
|
||||
for(int s2=0;s2<(1<<K);s2++)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
int now=dis[i][s1][s2];
|
||||
if(now==INF) continue;
|
||||
if(s2==((1<<K)-1)) ans=min(ans,now+adj[i][1]);
|
||||
for(int j=0;j<K;j++) if((s2&(1<<j))==0)
|
||||
{
|
||||
int &nxt=dis[pos[j]][ s1|pass[ pos[j] ] ][s2^(1<<j)];
|
||||
int add=adj[i][pos[j]];
|
||||
if(s1&(1<<j)) add+=FT[j];
|
||||
else add+=T[j];
|
||||
nxt=min(nxt,now+add);
|
||||
}
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
int &nxt=dis[j][s1|pass[j]][s2];
|
||||
int add=adj[i][j];
|
||||
nxt=min(nxt,now+add);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,t_cnt=0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
memset(dis,0x3f,sizeof(dis));
|
||||
memset(adj,0x3f,sizeof(adj));
|
||||
memset(pass,0,sizeof(pass));
|
||||
for(int i=0;i<N;i++) adj[i][i]=0;
|
||||
scanf("%d%d%d",&n,&m,&K);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
int a,b,c; scanf("%d%d%d",&a,&b,&c);
|
||||
adj[a][b]=adj[b][a]=c;
|
||||
}
|
||||
floyed();
|
||||
for(int i=0;i<K;i++)
|
||||
{
|
||||
scanf("%d%d%d",&pos[i],&T[i],&FT[i]);
|
||||
int num; scanf("%d",&num);
|
||||
for(int j=0;j<num;j++)
|
||||
{
|
||||
int tmp; scanf("%d",&tmp);
|
||||
pass[tmp]|=(1<<i);
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %d\n",++t_cnt,fun());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
const int MAXN=22000;
|
||||
bool visit[MAXN];
|
||||
queue<int>q1,q2;
|
||||
vector<vector<int> >adj;
|
||||
vector<vector<int> >radj;
|
||||
vector<vector<int> >dag;
|
||||
int n,m,cnt;
|
||||
int id[MAXN],order[MAXN],ind[MAXN];
|
||||
void dfs(int u)
|
||||
{
|
||||
visit[u]=true;
|
||||
int i,len=adj[u].size();
|
||||
for(i=0;i<len;i++)
|
||||
if(!visit[adj[u][i]])
|
||||
dfs(adj[u][i]);
|
||||
order[cnt++]=u;
|
||||
}
|
||||
void rdfs(int u)
|
||||
{
|
||||
visit[u]=true;
|
||||
id[u]=cnt;
|
||||
int i,len=radj[u].size();
|
||||
for(i=0;i<len;i++)
|
||||
if(!visit[radj[u][i]])
|
||||
rdfs(radj[u][i]);
|
||||
}
|
||||
void korasaju()
|
||||
{
|
||||
int i;
|
||||
memset(visit,false,sizeof(visit));
|
||||
for(cnt=0,i=0;i<2*n;i++)
|
||||
if(!visit[i])
|
||||
dfs(i);
|
||||
memset(id,0,sizeof(id));
|
||||
memset(visit,false,sizeof(visit));
|
||||
for(cnt=0,i=2*n-1;i>=0;i--)
|
||||
if(!visit[order[i]])
|
||||
{
|
||||
cnt++;
|
||||
rdfs(order[i]);
|
||||
}
|
||||
}
|
||||
bool solvable()
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
if(id[2*i]==id[2*i+1])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
void add(int x,int y)
|
||||
{
|
||||
adj[x].push_back(y);
|
||||
radj[y].push_back(x);
|
||||
}
|
||||
int a[MAXN],b[MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int x,y,z;
|
||||
scanf("%d",&T);
|
||||
int iCase=0;
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
if(a[i]==1)b[i]=2;
|
||||
else if(a[i]==2)b[i]=3;
|
||||
else b[i]=1;
|
||||
if(a[i]>b[i])swap(a[i],b[i]);
|
||||
}
|
||||
adj.assign(2*n,vector<int>());
|
||||
radj.assign(2*n,vector<int>());
|
||||
bool flag=true;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d%d",&x,&y,&z);
|
||||
x--;
|
||||
y--;
|
||||
if(!flag)continue;
|
||||
if(x==y)
|
||||
{
|
||||
if(z==1)flag=false;
|
||||
continue;
|
||||
}
|
||||
if(z==0)
|
||||
{
|
||||
if(a[x]!=a[y])
|
||||
{
|
||||
add(2*x,2*y+1);
|
||||
add(2*y,2*x+1);
|
||||
}
|
||||
if(a[x]!=b[y])
|
||||
{
|
||||
add(2*x,2*y);
|
||||
add(2*y+1,2*x+1);
|
||||
}
|
||||
if(b[x]!=a[y])
|
||||
{
|
||||
add(2*x+1,2*y+1);
|
||||
add(2*y,2*x);
|
||||
}
|
||||
if(b[x]!=b[y])
|
||||
{
|
||||
add(2*x+1,2*y);
|
||||
add(2*y+1,2*x);
|
||||
}
|
||||
}
|
||||
else if(z==1)
|
||||
{
|
||||
if(a[x]==a[y])
|
||||
{
|
||||
add(2*x,2*y+1);
|
||||
add(2*y,2*x+1);
|
||||
}
|
||||
if(a[x]==b[y])
|
||||
{
|
||||
add(2*x,2*y);
|
||||
add(2*y+1,2*x+1);
|
||||
}
|
||||
if(b[x]==a[y])
|
||||
{
|
||||
add(2*x+1,2*y+1);
|
||||
add(2*y,2*x);
|
||||
}
|
||||
if(b[x]==b[y])
|
||||
{
|
||||
add(2*x+1,2*y);
|
||||
add(2*y+1,2*x);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!flag)
|
||||
{
|
||||
printf("Case #%d: no\n",iCase);
|
||||
continue;
|
||||
}
|
||||
korasaju();
|
||||
if(solvable())printf("Case #%d: yes\n",iCase);
|
||||
else printf("Case #%d: no\n",iCase);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,244 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <cstdio>
|
||||
#include <queue>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define D(x)
|
||||
const int MAX_CHILD_NUM = 26;
|
||||
const int MAX_NODE_NUM = 3 * (int)1e5 + 10;
|
||||
const int MAX_LEN = 3 * (int)1e5 + 10;
|
||||
const int MAX_N = 2 * (int)1e4 + 10;
|
||||
#define MAX_EDGE_NUM MAX_NODE_NUM * 2
|
||||
struct Edge
|
||||
{
|
||||
int v, next;
|
||||
Edge()
|
||||
{}
|
||||
Edge(int v, int next):v(v), next(next)
|
||||
{}
|
||||
} edge[MAX_EDGE_NUM];
|
||||
int head[MAX_NODE_NUM];
|
||||
int edge_cnt;
|
||||
void init_edge()
|
||||
{
|
||||
memset(head, -1, sizeof(head));
|
||||
edge_cnt = 0;
|
||||
}
|
||||
void add_edge(int u, int v)
|
||||
{
|
||||
edge[edge_cnt] = Edge(v, head[u]);
|
||||
head[u] = edge_cnt++;
|
||||
}
|
||||
struct Trie
|
||||
{
|
||||
int next[MAX_NODE_NUM][MAX_CHILD_NUM];
|
||||
int fail[MAX_NODE_NUM];
|
||||
int count[MAX_NODE_NUM];
|
||||
int node_cnt;
|
||||
int root;
|
||||
bool vis[MAX_NODE_NUM]; //set it to false
|
||||
void init()
|
||||
{
|
||||
node_cnt = 0;
|
||||
root = newnode();
|
||||
}
|
||||
int newnode()
|
||||
{
|
||||
for (int i = 0; i < MAX_CHILD_NUM; i++)
|
||||
next[node_cnt][i] = -1;
|
||||
count[node_cnt++] = 0;
|
||||
return node_cnt - 1;
|
||||
}
|
||||
int get_id(char a)
|
||||
{
|
||||
return a - 'a';
|
||||
}
|
||||
void insert(char buf[], int index)
|
||||
{
|
||||
int now = root;
|
||||
for (int i = 0; buf[i]; i++)
|
||||
{
|
||||
int id = get_id(buf[i]);
|
||||
if (next[now][id] == -1)
|
||||
next[now][id] = newnode();
|
||||
now = next[now][id];
|
||||
}
|
||||
count[now] = index;
|
||||
}
|
||||
void build()
|
||||
{
|
||||
queue<int>Q;
|
||||
fail[root] = root;
|
||||
for (int i = 0; i < MAX_CHILD_NUM; i++)
|
||||
if (next[root][i] == -1)
|
||||
next[root][i] = root;
|
||||
else
|
||||
{
|
||||
fail[next[root][i]] = root;
|
||||
Q.push(next[root][i]);
|
||||
}
|
||||
while (!Q.empty())
|
||||
{
|
||||
int now = Q.front();
|
||||
Q.pop();
|
||||
for (int i = 0; i < MAX_CHILD_NUM; i++)
|
||||
if (next[now][i] == -1)
|
||||
next[now][i] = next[fail[now]][i];
|
||||
else
|
||||
{
|
||||
fail[next[now][i]]=next[fail[now]][i];
|
||||
Q.push(next[now][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
void build_fail_tree()
|
||||
{
|
||||
init_edge();
|
||||
for (int i = 1; i < node_cnt; i++)
|
||||
{
|
||||
add_edge(i, fail[i]);
|
||||
add_edge(fail[i], i);
|
||||
}
|
||||
}
|
||||
}ac;
|
||||
const int MAX_INTERVAL = MAX_LEN;
|
||||
struct SegmentTree
|
||||
{
|
||||
struct Node
|
||||
{
|
||||
int l, r;
|
||||
Node *pleft, *pright;
|
||||
int value;
|
||||
}tree[MAX_INTERVAL *4];
|
||||
int node_cnt;
|
||||
void init()
|
||||
{
|
||||
node_cnt = 0;
|
||||
}
|
||||
Node* new_node()
|
||||
{
|
||||
node_cnt++;
|
||||
return tree + node_cnt;
|
||||
}
|
||||
void build_tree(Node *proot, int s, int e)
|
||||
{
|
||||
proot->l = s;
|
||||
proot->r = e;
|
||||
proot->value = 0;
|
||||
if (s == e)
|
||||
{
|
||||
proot->pleft = proot->pright = NULL;
|
||||
return;
|
||||
}
|
||||
int mid = (s + e) / 2;
|
||||
build_tree(proot->pleft = new_node(), s, mid);
|
||||
build_tree(proot->pright = new_node(), mid + 1, e);
|
||||
}
|
||||
void pull_up(Node *proot)
|
||||
{
|
||||
}
|
||||
void push_down(Node *proot)
|
||||
{
|
||||
}
|
||||
void update(Node *proot, int start, int end, int value)
|
||||
{
|
||||
if (start > proot->r || end < proot->l)
|
||||
return;
|
||||
start = max(start, proot->l);
|
||||
end = min(end, proot->r);
|
||||
if (start == proot->l && end == proot->r)
|
||||
{
|
||||
proot->value = max(proot->value, value);
|
||||
return;
|
||||
}
|
||||
push_down(proot);
|
||||
update(proot->pleft, start, end, value);
|
||||
update(proot->pright, start, end, value);
|
||||
pull_up(proot);
|
||||
}
|
||||
int query(Node *proot, int start, int end)
|
||||
{
|
||||
int ret = proot->value;
|
||||
if (start > proot->r || end < proot->l)
|
||||
return 0;
|
||||
start = max(start, proot->l);
|
||||
end = min(end, proot->r);
|
||||
if (start == proot->l && end == proot->r)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
push_down(proot);
|
||||
ret = max(ret, query(proot->pleft, start, end));
|
||||
ret = max(ret, query(proot->pright, start, end));
|
||||
pull_up(proot);
|
||||
return ret;
|
||||
}
|
||||
}tree;
|
||||
char st[MAX_LEN];
|
||||
int pos[MAX_N];
|
||||
int dfn[MAX_LEN][2];
|
||||
int dfn_cnt;
|
||||
int n;
|
||||
int weight[MAX_N];
|
||||
void dfs(int u, int parent)
|
||||
{
|
||||
dfn[u][0] = ++dfn_cnt;
|
||||
for (int i = head[u]; i != -1; i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].v;
|
||||
if (v != parent)
|
||||
{
|
||||
dfs(v, u);
|
||||
}
|
||||
}
|
||||
dfn[u][1] = dfn_cnt;
|
||||
}
|
||||
int work()
|
||||
{
|
||||
int ret = 0;
|
||||
tree.init();
|
||||
tree.build_tree(tree.tree, 0, dfn_cnt);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
int u = ac.root;
|
||||
int temp = 0;
|
||||
for (int j = pos[i]; j < pos[i + 1]; j++)
|
||||
{
|
||||
u = ac.next[u][ac.get_id(st[j])];
|
||||
temp = max(temp, tree.query(tree.tree, dfn[u][0], dfn[u][0]) + weight[i]);
|
||||
}
|
||||
tree.update(tree.tree, dfn[u][0], dfn[u][1], temp);
|
||||
ret = max(ret, temp);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void input()
|
||||
{
|
||||
scanf("%d", &n);
|
||||
int temp = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%s%d", st + temp, &weight[i]);
|
||||
pos[i] = temp;
|
||||
ac.insert(st + temp, i);
|
||||
int len = strlen(st + temp);
|
||||
temp += len;
|
||||
}
|
||||
pos[n] = temp;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
for (int i = 1; i <= t; i++)
|
||||
{
|
||||
ac.init();
|
||||
input();
|
||||
ac.build();
|
||||
ac.build_fail_tree();
|
||||
dfn_cnt = 0;
|
||||
dfs(0, -1);
|
||||
printf("Case #%d: %d\n", i, work());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#pragma comment(linker, "/STACK:10240000000000,10240000000000")
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#define MAXN 101005
|
||||
#define MAXM 400005
|
||||
#define INF 1000000000
|
||||
using namespace std;
|
||||
struct EDGE
|
||||
{
|
||||
int v, next;
|
||||
long long w;
|
||||
}edge[MAXM];
|
||||
int head[MAXN], e;
|
||||
int n;
|
||||
int num[MAXN];
|
||||
long long ans;
|
||||
void init()
|
||||
{
|
||||
ans = 0;
|
||||
memset(head, -1, sizeof(head));
|
||||
e = 0;
|
||||
memset(num, 0, sizeof(num));
|
||||
}
|
||||
void add(int u, int v, long long w)
|
||||
{
|
||||
edge[e].v = v;
|
||||
edge[e].w = w;
|
||||
edge[e].next = head[u];
|
||||
head[u] = e++;
|
||||
}
|
||||
void dfs(int u, int fa)
|
||||
{
|
||||
num[u] = 1;
|
||||
for(int i = head[u]; i != -1; i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].v;
|
||||
if(v != fa)
|
||||
{
|
||||
dfs(v, u);
|
||||
num[u] += num[v];
|
||||
long long tmp = min(num[v], n - num[v]);
|
||||
ans += tmp * edge[i].w * 2LL;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, cas = 0, x, y, z;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d", &n);
|
||||
init();
|
||||
for(int i = 1; i < n; i++)
|
||||
{
|
||||
scanf("%d%d%d", &x, &y, &z);
|
||||
add(x, y, z);
|
||||
add(y, x, z);
|
||||
}
|
||||
dfs(1, 0);
|
||||
printf("Case #%d: %I64d\n", ++cas, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
#include <set>
|
||||
#include <string>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct Point
|
||||
{
|
||||
int x,y;
|
||||
Point(){}
|
||||
Point(int x,int y):x(x),y(y){}
|
||||
bool operator <(const Point& S)const
|
||||
{
|
||||
return x<S.x || x==S.x && y<S.y;
|
||||
}
|
||||
}P[4][666];
|
||||
struct TT
|
||||
{
|
||||
string s;
|
||||
bool ok;
|
||||
bool operator <(const TT& S)const
|
||||
{
|
||||
return s < S.s;
|
||||
}
|
||||
}Ans[4];
|
||||
int n,m;
|
||||
Point Rotary(Point A)
|
||||
{
|
||||
return Point(A.y,n+1-A.x);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int z,ncase=0;
|
||||
char tmp[25],map[55][55];
|
||||
set<string> Dic;
|
||||
scanf("%d",&z);
|
||||
while(z--)
|
||||
{
|
||||
Dic.clear();
|
||||
scanf("%d",&n);
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%s",map[i]+1);
|
||||
int top = 0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%s",map[0]+1);
|
||||
for(int j=1;j<=n;j++)
|
||||
if(map[0][j] == '*')
|
||||
P[0][top++] = Point(i,j);
|
||||
}
|
||||
for(int i=1;i<=3;i++)
|
||||
for(int j=0;j<top;j++)
|
||||
P[i][j] = Rotary(P[i-1][j]);
|
||||
for(int i=0;i<=3;i++)
|
||||
sort(P[i],P[i]+top);
|
||||
for(int k=0;k<=3;k++)
|
||||
Ans[k].ok = true;
|
||||
scanf("%d",&m);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
scanf("%s",tmp);
|
||||
Dic.insert(tmp);
|
||||
}
|
||||
for(int k=0;k<=3;k++)
|
||||
{
|
||||
int loc = -1;
|
||||
string& str = Ans[k].s;
|
||||
str = "";
|
||||
for(int i=k;i<k+4;i++)
|
||||
for(int j=0;j<top;j++)
|
||||
{
|
||||
char ttmp = map[ P[i%4][j].x ][ P[i%4][j].y ];
|
||||
str += ttmp=='.' ? ' ' : ttmp;
|
||||
}
|
||||
while(!str.empty() && str[0]==' ')
|
||||
str.erase(str.begin());
|
||||
for(int i=1;i<str.length();i++)
|
||||
if(str[i]==' ' && str[i-1]==' ')
|
||||
str.erase(str.begin()+(i--));
|
||||
if(!str.empty() && str[ str.length()-1 ]==' ')
|
||||
str.erase(str.end()-1);
|
||||
if(str.empty())
|
||||
{
|
||||
Ans[k].ok = false;
|
||||
continue;
|
||||
}
|
||||
while(++loc < str.length())
|
||||
{
|
||||
string word;
|
||||
while(loc<str.length() && str[loc]!=' ')
|
||||
word += str[loc++];
|
||||
if(Dic.find(word) == Dic.end())
|
||||
{
|
||||
Ans[k].ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
sort(Ans,Ans+4);
|
||||
printf("Case #%d: ",++ncase);
|
||||
int i;
|
||||
for(i=0;i<4;i++)
|
||||
if(Ans[i].ok)
|
||||
{
|
||||
puts(Ans[i].s.c_str());
|
||||
break;
|
||||
}
|
||||
if(i == 4)
|
||||
puts("FAIL TO DECRYPT");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#define LL __int64
|
||||
const int N = 10005;
|
||||
using namespace std;
|
||||
int a[N], n, k, s, t;
|
||||
int Ans()
|
||||
{
|
||||
int i;
|
||||
for( i = 1; i <= k; i ++ )
|
||||
if( a[i] < 0 )
|
||||
return 0;
|
||||
for( i = 1; i < k; i ++ )
|
||||
{
|
||||
a[i] -= a[i+1];
|
||||
if( a[i] )
|
||||
{
|
||||
n --;
|
||||
t -= a[i] * i;
|
||||
}
|
||||
}
|
||||
s = a[k];
|
||||
a[k] = 0;
|
||||
for( i = 1; i < k; i ++ )
|
||||
if( a[i] < 0 )
|
||||
return 0;
|
||||
if( n < 0 || s < n)
|
||||
return 0;
|
||||
if( n == 0 )
|
||||
{
|
||||
if( t == 0 && s == 0 )
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
if( n == 1 )
|
||||
{
|
||||
if( t%s == 0 && t/s >= k )
|
||||
{
|
||||
a[t/s] = s;
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
int ans(0), j, tt, mm = ( n*n-n ) / 2;
|
||||
for( i = k; i*s <= t-mm; i ++ )
|
||||
{
|
||||
tt = t-mm - i*s;
|
||||
if( tt == 0 )
|
||||
{
|
||||
for( j = 1; j < n; j ++ )
|
||||
a[k+j] = 1;
|
||||
a[k] = s-n+1;
|
||||
ans ++;
|
||||
}
|
||||
else if( tt > 1 && n > 2 )
|
||||
return 2;
|
||||
else if( tt > 1 && n == 2 )
|
||||
{
|
||||
tt += mm;
|
||||
for( j = 1; j < s; j ++ )
|
||||
{
|
||||
if( j > tt )
|
||||
break;
|
||||
else if( ans > 1 )
|
||||
return 2;
|
||||
if( tt%j == 0 )
|
||||
{
|
||||
a[ tt/j + i ] = j;
|
||||
a[i] = s-j;
|
||||
ans ++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if( s > n )
|
||||
return 2;
|
||||
else
|
||||
{
|
||||
for( j = 1; j < n-1; j ++ )
|
||||
a[k+j] = 1;
|
||||
a[k+n] = 1;
|
||||
a[k] = s-n+1;
|
||||
ans ++;
|
||||
}
|
||||
if( ans > 1 )
|
||||
return 2;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ca, cs, i, pre, now;
|
||||
scanf( "%d", &ca );
|
||||
for( cs = 1; cs <= ca; cs ++ )
|
||||
{
|
||||
memset( a, 0, sizeof(a) );
|
||||
scanf( "%d%d", &n, &k );
|
||||
scanf( "%d", &t );
|
||||
pre = t;
|
||||
for( i = 1; i <= k; i ++ )
|
||||
{
|
||||
scanf( "%d", &now );
|
||||
a[i] = pre - now;
|
||||
pre = now;
|
||||
}
|
||||
printf( "Case #%d:\n", cs );
|
||||
now = Ans();
|
||||
if( now < 1 )
|
||||
printf( "No Solution\n" );
|
||||
else if( now > 1 )
|
||||
printf( "Multiple Solutions\n" );
|
||||
else
|
||||
{
|
||||
printf( "Unique Solution\n" );
|
||||
for( i = 1; i < N; i ++ )
|
||||
if( a[i] )
|
||||
printf( "%d %d\n", i, a[i] );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std ;
|
||||
int abs(int x)
|
||||
{
|
||||
return x>0?x:-x ;
|
||||
}
|
||||
char map[11][11] ;
|
||||
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}} ;
|
||||
int RGX,RGY ;
|
||||
int xx,yy ;
|
||||
int ok(int x,int y)
|
||||
{
|
||||
if(y!=RGY)
|
||||
return 1 ;
|
||||
for(int i=x+1 ;i<RGX ;i++)
|
||||
if(map[i][y]!='0')
|
||||
return 1 ;
|
||||
return 0 ;
|
||||
}
|
||||
int cha(int x,int y)
|
||||
{
|
||||
if(x!=xx && y!=yy)
|
||||
return 0 ;
|
||||
if(x==xx)
|
||||
{
|
||||
int minn=min(y,yy) ;
|
||||
int maxn=max(y,yy) ;
|
||||
for(int i=minn+1 ;i<maxn ;i++)
|
||||
if(map[x][i]!='0')
|
||||
return 0 ;
|
||||
}
|
||||
if(y==yy)
|
||||
{
|
||||
int minn=min(x,xx) ;
|
||||
int maxn=max(x,xx) ;
|
||||
for(int i=minn+1 ;i<maxn ;i++)
|
||||
if(map[i][y]!='0')
|
||||
return 0 ;
|
||||
}
|
||||
return 1 ;
|
||||
}
|
||||
int hor(int x,int y)
|
||||
{
|
||||
if((abs(x-xx)==1 && abs(y-yy)==2) || (abs(x-xx)==2 &&abs(y-yy)==1))
|
||||
{
|
||||
if(xx-x==-2)
|
||||
{
|
||||
if(map[x-1][y]!='0')
|
||||
return 0 ;
|
||||
}
|
||||
if(xx-x==2)
|
||||
{
|
||||
if(map[x+1][y]!='0')
|
||||
return 0 ;
|
||||
}
|
||||
if(yy-y==-2)
|
||||
{
|
||||
if(map[x][y-1]!='0')
|
||||
return 0 ;
|
||||
}
|
||||
if(yy-y==2)
|
||||
{
|
||||
if(map[x][y+1]!='0')
|
||||
return 0 ;
|
||||
}
|
||||
return 1 ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
int can(int x,int y)
|
||||
{
|
||||
if(x!=xx && y!=yy)
|
||||
return 0 ;
|
||||
int flag=0 ;
|
||||
if(x==xx)
|
||||
{
|
||||
int minn=min(y,yy) ;
|
||||
int maxn=max(y,yy) ;
|
||||
for(int i=minn+1 ;i<maxn ;i++)
|
||||
if(map[x][i]!='0')
|
||||
flag++ ;
|
||||
}
|
||||
if(y==yy)
|
||||
{
|
||||
int minn=min(x,xx) ;
|
||||
int maxn=max(x,xx) ;
|
||||
for(int i=minn+1 ;i<maxn ;i++)
|
||||
if(map[i][y]!='0')
|
||||
flag++ ;
|
||||
}
|
||||
if(flag==1)
|
||||
return 1 ;
|
||||
return 0 ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n ;
|
||||
int x,y ;
|
||||
while(~scanf("%d%d%d%*c",&n,&x,&y))
|
||||
{
|
||||
if(n==0 && x==0 && y==0)
|
||||
break ;
|
||||
for(int i=0 ;i<11 ;i++)
|
||||
for(int j=0 ;j<11 ;j++)
|
||||
map[i][j]='0' ;
|
||||
for(int i=0 ;i<n ;i++)
|
||||
{
|
||||
char chr ;
|
||||
int a,b ;
|
||||
cin >> chr >> a >> b ;
|
||||
map[a][b]=chr ;
|
||||
if(chr=='G')
|
||||
{
|
||||
RGX=a ;RGY=b ;
|
||||
}
|
||||
}
|
||||
int flag ;
|
||||
for(int i=0 ;i<4 ;i++)
|
||||
{
|
||||
flag=0 ;
|
||||
xx=x+dir[i][0] ;
|
||||
yy=y+dir[i][1] ;
|
||||
if(xx<1 || xx>3){flag=1 ;continue ;}
|
||||
if(yy<4 || yy>6){flag=1 ;continue ;}
|
||||
if(!ok(xx,yy)){flag=1 ;continue ;}
|
||||
char t=map[xx][yy] ;
|
||||
map[xx][yy]='0' ;
|
||||
for(int j=1 ;j<=10 ;j++)
|
||||
{
|
||||
for(int k=1 ;k<=9 ;k++)
|
||||
{
|
||||
if(map[j][k]=='R')
|
||||
{
|
||||
if(cha(j,k))
|
||||
flag=1 ;
|
||||
}
|
||||
if(map[j][k]=='H')
|
||||
{
|
||||
if(hor(j,k))
|
||||
flag=1 ;
|
||||
}
|
||||
if(map[j][k]=='C')
|
||||
{
|
||||
if(can(j,k))
|
||||
flag=1 ;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!flag)
|
||||
break ;
|
||||
map[xx][yy]=t ;
|
||||
}
|
||||
if(flag)
|
||||
puts("YES") ;
|
||||
else
|
||||
puts("NO") ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 99999999
|
||||
using namespace std;
|
||||
const int MAX=2500+10;
|
||||
char mon[5];
|
||||
int M[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
|
||||
struct Node{
|
||||
int num,t;
|
||||
}order[MAX],q[MAX*4];
|
||||
int MON(char *m){
|
||||
if(strcmp(m,"Jan") == 0)return 1;
|
||||
if(strcmp(m,"Feb") == 0)return 2;
|
||||
if(strcmp(m,"Mar") == 0)return 3;
|
||||
if(strcmp(m,"Apr") == 0)return 4;
|
||||
if(strcmp(m,"May") == 0)return 5;
|
||||
if(strcmp(m,"Jun") == 0)return 6;
|
||||
if(strcmp(m,"Jul") == 0)return 7;
|
||||
if(strcmp(m,"Aug") == 0)return 8;
|
||||
if(strcmp(m,"Sep") == 0)return 9;
|
||||
if(strcmp(m,"Oct") == 0)return 10;
|
||||
if(strcmp(m,"Nov") == 0)return 11;
|
||||
return 12;
|
||||
}
|
||||
bool LeapYear(int &year){
|
||||
return year%4 == 0 && year%100 || year%400 == 0;
|
||||
}
|
||||
int Time(int &year,int Mon,int &d,int &h){
|
||||
int t=0;
|
||||
for(int i=2000;i<year;++i){
|
||||
if(LeapYear(i))t+=366;
|
||||
else t+=365;
|
||||
}
|
||||
bool flag=LeapYear(year);
|
||||
for(int i=1;i<Mon;++i){
|
||||
if(flag && i == 2)t+=29;
|
||||
else t+=M[i];
|
||||
}
|
||||
t+=d-1;
|
||||
return t*24+h;
|
||||
}
|
||||
int main(){
|
||||
int n,m,t,s,r,h,d,year,a;
|
||||
while(~scanf("%d%d",&n,&m),n+m){
|
||||
for(int i=0;i<n;++i){
|
||||
scanf("%s%d%d%d%d",mon,&d,&year,&h,&r);
|
||||
order[i].num=r,order[i].t=Time(year,MON(mon),d,h);
|
||||
}
|
||||
int top=0,tail=0,p=0;
|
||||
__int64 sum=0;
|
||||
scanf("%d%d",&t,&s);
|
||||
for(int i=0;i<m;++i){
|
||||
scanf("%d",&a);
|
||||
while(top<tail && q[tail-1].num+(i-q[tail-1].t)*s>=a)--tail;
|
||||
q[tail].num=a,q[tail++].t=i;
|
||||
while(p<n && i == order[p].t){
|
||||
while(q[top].t+t<i)++top;
|
||||
sum+=(q[top].num+(i-q[top].t)*s)*order[p++].num;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
#include<algorithm>
|
||||
#include<string>
|
||||
#define N 50010
|
||||
#define M 510
|
||||
#define inf 200000000
|
||||
int w[N],edge,id[N],an[M];
|
||||
__int64 dp[N][2],dis[N];
|
||||
struct qq{
|
||||
int id;
|
||||
__int64 l;
|
||||
}q[M];
|
||||
bool cmp(const qq &a,const qq &b){
|
||||
return a.l<b.l;
|
||||
}
|
||||
struct node{
|
||||
int v,next;
|
||||
__int64 l;
|
||||
}e[N*2];
|
||||
void add(int u,int v,__int64 l){
|
||||
e[edge].v=v;
|
||||
e[edge].l=l;
|
||||
e[edge].next=w[u];
|
||||
w[u]=edge++;
|
||||
}
|
||||
void dfs1(int u,int no){
|
||||
for(int i=w[u];i!=-1;i=e[i].next){
|
||||
int v=e[i].v;
|
||||
if(v!=no){
|
||||
dfs1(v,u);
|
||||
if(dp[v][0]+e[i].l>dp[u][0]){
|
||||
dp[u][1]=dp[u][0];
|
||||
id[u]=v,dp[u][0]=dp[v][0]+e[i].l;
|
||||
}
|
||||
else if(dp[v][0]+e[i].l>dp[u][1]) dp[u][1]=dp[v][0]+e[i].l;
|
||||
}
|
||||
}
|
||||
}
|
||||
void dfs2(int u,int no,__int64 l){
|
||||
dis[u]=max(l,dp[u][0]);
|
||||
for(int i=w[u];i!=-1;i=e[i].next){
|
||||
int v=e[i].v;
|
||||
if(v!=no){
|
||||
if(v==id[u]) dfs2(v,u,max(l,dp[u][1])+e[i].l);
|
||||
else dfs2(v,u,dis[u]+e[i].l);
|
||||
}
|
||||
}
|
||||
}
|
||||
int dp_max[N][20],dp_min[N][20];
|
||||
__int64 p[20];
|
||||
int max_id(int x,int y){
|
||||
return dis[x]>dis[y]?x:y;
|
||||
}
|
||||
int min_id(int x,int y){
|
||||
return dis[x]>dis[y]?y:x;
|
||||
}
|
||||
int log(int x){
|
||||
int i=0;
|
||||
while(p[i]<=x) i++;
|
||||
return i-1;
|
||||
}
|
||||
int get_max_id(int x,int y){
|
||||
int t=log(y-x+1);
|
||||
return max_id(dp_max[x][t],dp_max[y-p[t]+1][t]);
|
||||
}
|
||||
int get_min_id(int x,int y){
|
||||
int t=log(y-x+1);
|
||||
return min_id(dp_min[x][t],dp_min[y-p[t]+1][t]);
|
||||
}
|
||||
__int64 get_min(int x,int y){
|
||||
return dis[get_min_id(x,y)];
|
||||
}
|
||||
__int64 get_max(int x,int y){
|
||||
return dis[get_max_id(x,y)];
|
||||
}
|
||||
void RMQ(int n){
|
||||
int i,j,l=n,t=0;
|
||||
p[0]=1;
|
||||
for(i=1;i<18;i++)
|
||||
p[i]=p[i-1]<<1;
|
||||
t=log(n);
|
||||
for(i=1;i<=n;i++)
|
||||
dp_max[i][0]=dp_min[i][0]=i;
|
||||
for(i=1;i<=t;i++){
|
||||
l=n-p[i]+1;
|
||||
for(j=1;j<=l;j++){
|
||||
dp_max[j][i]=max_id(dp_max[j][i-1],dp_max[j+p[i-1]][i-1]);
|
||||
dp_min[j][i]=min_id(dp_min[j][i-1],dp_min[j+p[i-1]][i-1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int n,m,a,b;
|
||||
__int64 c;
|
||||
while(scanf("%d%d",&n,&m)){
|
||||
if(!n&&!m) break;
|
||||
edge=0;
|
||||
memset(w,-1,sizeof(int)*(n+1));
|
||||
for(int i=1;i<n;++i){
|
||||
scanf("%d%d%I64d",&a,&b,&c);
|
||||
add(a,b,c);
|
||||
add(b,a,c);
|
||||
}
|
||||
memset(dis,0,sizeof(__int64)*(n+1));
|
||||
memset(dp,0,sizeof(dp));
|
||||
dfs1(1,1);
|
||||
dfs2(1,1,0);
|
||||
RMQ(n);
|
||||
for(int i=0;i<m;++i){
|
||||
scanf("%I64d",&q[i].l);
|
||||
q[i].id=i;
|
||||
}
|
||||
sort(q,q+m,cmp);
|
||||
for(int i=0;i<m;++i){
|
||||
int ans,start=1;
|
||||
if(!i) ans=1;
|
||||
else ans=an[q[i-1].id];
|
||||
while(1){
|
||||
int j=start+ans-1;
|
||||
for(;j<=n&&get_max(start,j)-get_min(start,j)<=q[i].l;++j);
|
||||
if(ans<j-start) ans=j-start;
|
||||
if(j==n+1) break;
|
||||
++start;
|
||||
}
|
||||
an[q[i].id]=ans;
|
||||
}
|
||||
for(int i=0;i<m;++i) printf("%d\n",an[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,175 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
char s[2000000],ss[10000];
|
||||
int sta[700000],top,root,ch[700000][2],cnt;
|
||||
int zhu[700000],C[700000];
|
||||
inline void f()
|
||||
{
|
||||
zhu[root]=0;cnt=0;
|
||||
sta[0]=root,top=1;
|
||||
if(!ch[root][0]&&!ch[root][1])
|
||||
{
|
||||
s[0]=root%2+'0';
|
||||
return;
|
||||
}
|
||||
int t=root;
|
||||
while(t-root||((zhu[t]==1&&ch[t][1])||zhu[t]==0))
|
||||
{
|
||||
s[cnt++]=t%2+'0';
|
||||
if(top<0)
|
||||
return;
|
||||
if(zhu[t]==0)
|
||||
{
|
||||
if(ch[t][0])
|
||||
{
|
||||
zhu[t]=1;
|
||||
t=ch[t][0];
|
||||
zhu[t]=0;
|
||||
sta[top++]=t;
|
||||
}
|
||||
else if(ch[t][1])
|
||||
{
|
||||
zhu[t]=2;
|
||||
t=ch[t][1];
|
||||
zhu[t]=0;
|
||||
sta[top++]=t;
|
||||
}
|
||||
else if(t==root)
|
||||
return ;
|
||||
else
|
||||
zhu[t]=2,t=sta[--top-1];
|
||||
}
|
||||
else if(zhu[t]==1)
|
||||
{
|
||||
if(ch[t][1])
|
||||
{
|
||||
zhu[t]=2;
|
||||
t=ch[t][1];
|
||||
zhu[t]=0;
|
||||
sta[top++]=t;
|
||||
}
|
||||
else if(t==root)
|
||||
return ;
|
||||
else
|
||||
t=sta[--top-1];
|
||||
}
|
||||
else if(t==root)
|
||||
return ;
|
||||
else
|
||||
t=sta[--top-1];
|
||||
}
|
||||
s[cnt++]=root%2+'0';
|
||||
}
|
||||
int P[10000];
|
||||
inline void scan(int &u)
|
||||
{
|
||||
char c;
|
||||
while(c=getchar(),c<'0'||c>'9');
|
||||
u=c-'0';
|
||||
while(c=getchar(),c<='9'&&c>='0')
|
||||
u=u*10+c-'0';
|
||||
}
|
||||
int ff(int l)
|
||||
{
|
||||
int i,j,ans=0;
|
||||
P[0]=-1;
|
||||
for(i=1,j=-1;i<l;i++)
|
||||
{
|
||||
while(j+1&&ss[j+1]-ss[i])
|
||||
j=P[j];
|
||||
if(ss[j+1]==ss[i])
|
||||
j++;
|
||||
P[i]=j;
|
||||
}
|
||||
for(i=0,j=-1;i<cnt;i++)
|
||||
{
|
||||
while(j+1&&ss[j+1]-s[i])
|
||||
j=P[j];
|
||||
if(ss[j+1]==s[i])
|
||||
j++;
|
||||
if(j==l-1)
|
||||
ans++;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int N,Min,Max;
|
||||
int cal(int n)
|
||||
{
|
||||
int ans=0;
|
||||
while(n>=1)
|
||||
ans+=C[n],n-=n&(-n);
|
||||
return ans;
|
||||
}
|
||||
void update(int n)
|
||||
{
|
||||
while(n<=N)
|
||||
C[n]++,n+=n&(-n);
|
||||
}
|
||||
void insert(int n)
|
||||
{
|
||||
update(n);
|
||||
int t=cal(n);
|
||||
if(!root)
|
||||
{
|
||||
root=n;
|
||||
Min=Max=n;
|
||||
return;
|
||||
}
|
||||
if(n>Max)
|
||||
{
|
||||
ch[Max][1]=n;
|
||||
Max=n;
|
||||
return;
|
||||
}
|
||||
if(n<Min)
|
||||
{
|
||||
ch[Min][0]=n;
|
||||
Min=n;
|
||||
return;
|
||||
}
|
||||
int l=1,r=n-1,mid;
|
||||
Min=Min<n?Min:n;
|
||||
Max=Max>n?Max:n;
|
||||
while(l<r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(cal(mid)==t-1)
|
||||
r=mid;
|
||||
else
|
||||
l=mid+1;
|
||||
}
|
||||
l=r;
|
||||
if(!ch[l][1])
|
||||
{
|
||||
ch[l][1]=n;
|
||||
return;
|
||||
}
|
||||
l=n+1,r=N;
|
||||
while(l<r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if(cal(mid)-t)
|
||||
r=mid;
|
||||
else
|
||||
l=mid+1;
|
||||
}
|
||||
ch[r][0]=n;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,n,i,j;
|
||||
scanf("%d",&t);
|
||||
for(int ii=1;ii<=t;ii++)
|
||||
{
|
||||
memset(ch,0,sizeof(ch));
|
||||
memset(C,0,sizeof(C));
|
||||
Min=1000000,Max=0;
|
||||
root=0;
|
||||
scanf("%d",&n);N=n;
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&j),insert(j);
|
||||
f();
|
||||
scanf("%s",ss);
|
||||
printf("Case #%d: %d\n",ii,ff(strlen(ss)));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
const int maxn = 3003;
|
||||
const int maxm = maxn * maxn;
|
||||
const int inf = 1000000000;
|
||||
int n, m;
|
||||
__int64 mst;
|
||||
int map[maxn][maxn];
|
||||
int dp[maxn][maxn];
|
||||
int dis[maxn], pre[maxn];
|
||||
bool vis[maxn];
|
||||
vector<int> edge[maxn];
|
||||
int minz(int a, int b)
|
||||
{
|
||||
return a < b ? a : b;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
for(j = 0; j < n; j++)
|
||||
map[i][j] = dp[i][j] = inf;
|
||||
edge[i].clear();
|
||||
vis[i] = 0;
|
||||
pre[i] = -1;
|
||||
dis[i] = inf;
|
||||
}
|
||||
}
|
||||
void input()
|
||||
{
|
||||
int x, y, z;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d%d", &x, &y, &z);
|
||||
map[x][y] = map[y][x] = z;
|
||||
}
|
||||
}
|
||||
void prim()
|
||||
{
|
||||
int i, j, k;
|
||||
for(i = 1; i < n; i++)
|
||||
{
|
||||
dis[i] = map[0][i];
|
||||
pre[i] = 0;
|
||||
}
|
||||
dis[0] = inf;
|
||||
vis[0] = 1;
|
||||
pre[0] = -1;
|
||||
mst = 0;
|
||||
for(i = 0; i < n-1; i++)
|
||||
{
|
||||
k = 0;
|
||||
for(j = 1; j < n; j++)
|
||||
if(!vis[j] && dis[k] > dis[j])
|
||||
k = j;
|
||||
vis[k] = 1;
|
||||
mst += dis[k];
|
||||
if(pre[k] != -1)
|
||||
edge[k].push_back(pre[k]),
|
||||
edge[pre[k]].push_back(k);
|
||||
for(j = 1; j < n; j++)
|
||||
if(!vis[j] && dis[j] > map[k][j] )
|
||||
dis[j] = map[k][j], pre[j] = k;
|
||||
}
|
||||
}
|
||||
int dfs(int pos, int u, int fa)
|
||||
{
|
||||
int i, ans = inf;
|
||||
for(i = 0; i < edge[u].size(); i++)
|
||||
{
|
||||
int v = edge[u][i];
|
||||
if(v == fa) continue;
|
||||
int tmp = dfs(pos, v, u);
|
||||
ans = minz(ans, tmp);
|
||||
dp[u][v] = dp[v][u] = minz(dp[u][v], tmp);
|
||||
}
|
||||
if(pos != fa)
|
||||
ans = minz(ans, map[pos][u]);
|
||||
return ans;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < n; i++)
|
||||
dfs(i, i, -1);
|
||||
}
|
||||
void query()
|
||||
{
|
||||
int x, y, z;
|
||||
double sum = 0;
|
||||
scanf("%d", &m);
|
||||
for(int ii = 1; ii <= m; ii++)
|
||||
{
|
||||
scanf("%d%d%d", &x, &y, &z);
|
||||
if(pre[x] != y && pre[y] != x)
|
||||
sum += mst * 1.0;
|
||||
else
|
||||
sum += mst * 1.0 - map[x][y] + minz(dp[x][y], z);
|
||||
}
|
||||
printf("%.4f\n", sum/m);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while( ~scanf("%d%d", &n, &m) && n + m)
|
||||
{
|
||||
init();
|
||||
input();
|
||||
prim();
|
||||
solve();
|
||||
query();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<map>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<set>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#define inf 1<<30
|
||||
#define M 60005
|
||||
#define N 10005
|
||||
#define maxn 300005
|
||||
#define eps 1e-10
|
||||
#define zero(a) fabs(a)<eps
|
||||
#define Min(a,b) ((a)<(b)?(a):(b))
|
||||
#define Max(a,b) ((a)>(b)?(a):(b))
|
||||
#define pb(a) push_back(a)
|
||||
#define mem(a,b) memset(a,b,sizeof(a))
|
||||
#define LL long long
|
||||
#define lson step<<1
|
||||
#define rson step<<1|1
|
||||
#define MOD 1000000009
|
||||
using namespace std;
|
||||
int maze[10][10];
|
||||
int n;
|
||||
int way[4][2]={0,1,0,-1,1,0,-1,0};
|
||||
int vis[10][10];
|
||||
bool check(int x,int y)
|
||||
{
|
||||
if(x<0||y<0||x>=n||y>=n) return false;
|
||||
return true;
|
||||
}
|
||||
void floodfill(int x,int y,int c)
|
||||
{
|
||||
vis[x][y]=1;
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
int tx=x+way[i][0];
|
||||
int ty=y+way[i][1];
|
||||
if(!check(tx,ty)) continue;
|
||||
if(vis[tx][ty]==1) continue;
|
||||
if(maze[tx][ty]==c) floodfill(tx,ty,c);
|
||||
else vis[tx][ty]=2;
|
||||
}
|
||||
}
|
||||
int get_cnt(int col)
|
||||
{
|
||||
int cnt=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
if(maze[i][j]==col&&vis[i][j]==2)
|
||||
{
|
||||
cnt++;
|
||||
floodfill(i,j,maze[i][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
int get_h()
|
||||
{
|
||||
bool flag[6];mem(flag,false);
|
||||
int cnt=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
if(vis[i][j]!=1&&!flag[maze[i][j]])
|
||||
{
|
||||
cnt++;
|
||||
flag[maze[i][j]]=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
int depth;
|
||||
bool IDAstar(int dep)
|
||||
{
|
||||
if(depth==dep) return get_h()==0;
|
||||
if(dep+get_h()>depth) return false;
|
||||
for(int i=0;i<6;i++)
|
||||
{
|
||||
int tmp[10][10];
|
||||
memcpy(tmp,vis,sizeof(vis));
|
||||
if(get_cnt(i)==0) continue;
|
||||
if(IDAstar(dep+1)) return true;
|
||||
memcpy(vis,tmp,sizeof(vis));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n)!=EOF&&n)
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
scanf("%d",&maze[i][j]);
|
||||
}
|
||||
}
|
||||
mem(vis,0);
|
||||
floodfill(0,0,maze[0][0]);
|
||||
depth=get_h();
|
||||
while(true)
|
||||
{
|
||||
if(IDAstar(0)) break;
|
||||
depth++;
|
||||
}
|
||||
printf("%d\n",depth);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
struct Node
|
||||
{
|
||||
long long s,t;
|
||||
}node[11000];
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
return ((Node *)b)->s-((Node *)a)->s;
|
||||
}
|
||||
long long S[11000],T[11000],N;
|
||||
int ff(int s,int t)
|
||||
{
|
||||
if(N==1)
|
||||
return 1;
|
||||
if(N==2)
|
||||
{
|
||||
if((T[1]-t)*(S[2]-s)<(S[1]-s)*(T[2]-t))
|
||||
return 1;
|
||||
return 2;
|
||||
}
|
||||
int l=2,r=N-1,mid;
|
||||
while(l<r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
if((T[mid]-t)*(S[mid-1]-s)<=(T[mid-1]-t)*(S[mid]-s)&&(T[mid]-t)*(S[mid+1]-s)<=(T[mid+1]-t)*(S[mid]-s))
|
||||
l=r=mid;
|
||||
else if((T[mid]-t)*(S[mid-1]-s)<(T[mid-1]-t)*(S[mid]-s)&&(T[mid]-t)*(S[mid+1]-s)>=(T[mid+1]-t)*(S[mid]-s))
|
||||
l=mid+1;
|
||||
else
|
||||
r=mid-1;
|
||||
}
|
||||
if((T[1]-t)*(S[r]-s)<(T[r]-t)*(S[1]-s))
|
||||
r=1;
|
||||
if((T[N]-t)*(S[r]-s)<(T[r]-t)*(S[N]-s))
|
||||
r=N;
|
||||
return r;
|
||||
}
|
||||
int q[11000],f,r,qq[11000];
|
||||
int main()
|
||||
{
|
||||
long long n,s,w,d,L,j;
|
||||
int i,t;
|
||||
double ans;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%I64d%I64d%I64d%I64d",&n,&d,&L,&w);
|
||||
for(i=1,s=0;i<=n;i++)
|
||||
scanf("%I64d%I64d",&node[i].s,&node[i].t),s+=d*node[i].t,w-=node[i].s*d;
|
||||
L-=d*n;
|
||||
if(L<0||w<0)
|
||||
{
|
||||
printf("No solution\n");
|
||||
continue;
|
||||
}
|
||||
qsort(node+1,n,sizeof(Node),cmp);
|
||||
for(i=1,f=1,r=0;i<=n;i++)
|
||||
{
|
||||
while(f<=r&&node[i].t<node[q[r]].t)
|
||||
r--;
|
||||
q[++r]=i;
|
||||
}
|
||||
n=r;
|
||||
for(i=1;i<=n&&L*node[q[i]].s>w;i++);
|
||||
if(i>n)
|
||||
{
|
||||
printf("No solution\n");
|
||||
continue;
|
||||
}
|
||||
else if(L*(node[q[1]].s)<=w)
|
||||
{
|
||||
printf("%.2f\n",s+L*node[q[1]].t+0.0);
|
||||
continue;
|
||||
}
|
||||
r=i;
|
||||
S[1]=node[q[1]].s,T[1]=node[q[1]].t;
|
||||
for(i=2,N=1,qq[1]=q[1];i<r;i++)
|
||||
{
|
||||
while(N>1&&((node[qq[N-1]].t-node[qq[N]].t)*(node[qq[N]].s-node[q[i]].s)<=(node[qq[N]].t-node[q[i]].t)*(node[qq[N-1]].s-node[qq[N]].s)))
|
||||
N--;
|
||||
qq[++N]=q[i];
|
||||
}
|
||||
for(i=1;i<=N;i++)
|
||||
S[i]=node[qq[i]].s,T[i]=node[qq[i]].t;
|
||||
for(ans=4000000000,i=r;i<=n;i++)
|
||||
{
|
||||
j=ff(node[q[i]].s,node[q[i]].t);
|
||||
j=qq[j];
|
||||
double tt=L*node[q[i]].t+(w-L*node[q[i]].s)*((node[q[i]].t-node[j].t+0.0)/(node[q[i]].s-node[j].s+0.0));
|
||||
if(tt<ans)
|
||||
ans=tt;
|
||||
}
|
||||
printf("%.2f\n",ans+s);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 50000;
|
||||
struct node
|
||||
{
|
||||
int s;
|
||||
int e;
|
||||
int v;
|
||||
}seg[maxn+5];
|
||||
struct hashnode
|
||||
{
|
||||
int rv;
|
||||
int id;
|
||||
}index[maxn*2+5];
|
||||
bool cmp(const hashnode &a, const hashnode &b)
|
||||
{
|
||||
return a.rv<b.rv;
|
||||
}
|
||||
int f[maxn*2+5];
|
||||
inline int lowbit(int x)
|
||||
{
|
||||
return x & (-x);
|
||||
}
|
||||
inline void _update(int x, int d)
|
||||
{
|
||||
int i;
|
||||
for (i=x; i>0; i-=lowbit(i))
|
||||
{
|
||||
f[i] += d;
|
||||
}
|
||||
}
|
||||
inline void update(int l, int r, int d)
|
||||
{
|
||||
_update(l-1, -d);
|
||||
_update(r, d);
|
||||
}
|
||||
inline int getpt(int x, int n)
|
||||
{
|
||||
int i, s = 0;
|
||||
for (i=x; i<=n; i+=lowbit(i))
|
||||
{
|
||||
s += f[i];
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int bs(int v, int s, int t)
|
||||
{
|
||||
int l=s-1, r=t+1, m, ans;
|
||||
while(l<=r)
|
||||
{
|
||||
m = (l+r)>>1;
|
||||
if (v<=index[m].rv)
|
||||
{
|
||||
ans = m;
|
||||
r = m-1;
|
||||
}
|
||||
else l = m+1;
|
||||
}
|
||||
return index[ans].id;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
int len;
|
||||
double amt;
|
||||
int n;
|
||||
int i, j;
|
||||
int a, b;
|
||||
int end;
|
||||
double ans;
|
||||
scanf("%d", &t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d %lf", &len, &amt);
|
||||
scanf("%d", &n);
|
||||
index[1].rv = 0;
|
||||
index[2].rv = len;
|
||||
for (i=0,j=3; i<n; i++,j+=2)
|
||||
{
|
||||
scanf("%d %d %d", &seg[i].s, &seg[i].e, &seg[i].v);
|
||||
index[j].rv = seg[i].s;
|
||||
index[j+1].rv = seg[i].e;
|
||||
}
|
||||
end = j-1;
|
||||
sort(index+1, index+end+1, cmp);
|
||||
index[1].id = 1;
|
||||
for (i=2,j=2; i<=end; i++)
|
||||
{
|
||||
if (index[i].rv!=index[j-1].rv)
|
||||
{
|
||||
index[j].rv = index[i].rv;
|
||||
index[j].id = j;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
end = j-1;
|
||||
memset(f, 0, sizeof(f));
|
||||
update(1, end-1, 1);
|
||||
for (i=0; i<n; i++)
|
||||
{
|
||||
a = bs(seg[i].s, 1, end);
|
||||
b = bs(seg[i].e, 1, end);
|
||||
update(a, b-1, seg[i].v);
|
||||
}
|
||||
ans = 0;
|
||||
for (i=1; i<end && fabs(amt)>1e-6; i++)
|
||||
{
|
||||
a = index[i+1].rv-index[i].rv;
|
||||
b = getpt(i, end);
|
||||
if (a*1.0>amt/b)
|
||||
{
|
||||
ans += amt/b;
|
||||
amt = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans += a;
|
||||
amt -= a*b;
|
||||
}
|
||||
}
|
||||
printf("%.2lf\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include<stdio.h>
|
||||
__int64 prime[16]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
|
||||
__int64 n,cnter,ans;
|
||||
void dfs(__int64 cur,__int64 cnt,__int64 power,__int64 sub)
|
||||
{
|
||||
__int64 i;
|
||||
if(cur>n)
|
||||
return;
|
||||
if(cnt==cnter&&cur<ans)
|
||||
ans=cur;
|
||||
if(cnt>cnter)
|
||||
{
|
||||
ans=cur;
|
||||
cnter=cnt;
|
||||
}
|
||||
__int64 p=prime[sub];
|
||||
for(i=1;i<=power;i++)
|
||||
{
|
||||
if(cur*p>n)
|
||||
break;
|
||||
dfs(cur*p,cnt*(i+1),i,sub+1);
|
||||
p=p*prime[sub];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,T;
|
||||
scanf("%d",&T);
|
||||
for(t=1;t<=T;t++)
|
||||
{
|
||||
scanf("%I64d",&n);
|
||||
cnter=0,ans=0;
|
||||
dfs(1,1,50,0);
|
||||
printf("Case #%d: %I64d\n",t,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include<stdio.h>
|
||||
int a[110];
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
int ca = 1;
|
||||
while(t--){
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
int i,j;
|
||||
for(i=1;i<=n;i++)scanf("%d",&a[i]);
|
||||
int win = 0;
|
||||
i = 1,j = n;
|
||||
while(1){
|
||||
if(j-i+1==2){
|
||||
if(a[1]>a[2])win = 1;
|
||||
else win = 2;
|
||||
break;
|
||||
}
|
||||
int ii = i,jj = j;
|
||||
while(ii<=jj){
|
||||
a[ii++] += a[jj--];
|
||||
}
|
||||
i = 1,j = (j+1)/2;
|
||||
}
|
||||
printf("Case #%d: ",ca++);
|
||||
if(win==1)puts("Alice");
|
||||
else if(win==2)puts("Bob");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
long long a,b,n;
|
||||
vector<long long> vt;
|
||||
long long solve(long long x,long long n){
|
||||
vt.clear();
|
||||
long long i,j;
|
||||
for(i=2;i*i<=n;i++)
|
||||
if(n%i==0){
|
||||
vt.push_back(i);
|
||||
while(n%i==0)
|
||||
n/=i;
|
||||
}
|
||||
if(n>1)
|
||||
vt.push_back(n);
|
||||
long long sum=0,val,cnt;
|
||||
for(i=1;i<(1<<vt.size());i++){
|
||||
val=1;
|
||||
cnt=0;
|
||||
for(j=0;j<vt.size();j++)
|
||||
if(i&(1<<j)){
|
||||
val*=vt[j];
|
||||
cnt++;
|
||||
}
|
||||
if(cnt&1)
|
||||
sum+=x/val;
|
||||
else
|
||||
sum-=x/val;
|
||||
}
|
||||
return x-sum;
|
||||
}
|
||||
int main(){
|
||||
int t,cases=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
cin>>a>>b>>n;
|
||||
cout<<"Case #"<<++cases<<": "<<solve(b,n)-solve(a-1,n)<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include<algorithm>
|
||||
#include<stdlib.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
#define eps 1e-10
|
||||
#define N 100015
|
||||
#define db double
|
||||
db ans,p1,p2,win1,win2,win_num[2][2][2],dp[2][2][2];
|
||||
int sign(db x){
|
||||
return (x > eps) - (x < -eps);
|
||||
}
|
||||
void dfs(int pl1,db p,int pl2,int v,int s){
|
||||
if((pl1 == 6&&pl2 <= 4)||pl1 == 7){
|
||||
win_num[s][0][v] += p*(pl1+pl2)*5.;
|
||||
dp[s][0][v] += p;
|
||||
return ;
|
||||
}
|
||||
if((pl2 == 6&&pl1 <= 4)||pl2 == 7){
|
||||
win_num[s][1][v] += p*(pl1+pl2)*5.;
|
||||
dp[s][1][v] += p;
|
||||
return ;
|
||||
}
|
||||
if(v) dfs(pl1,p*p2,pl2+1,v^1,s),dfs(pl1+1,p*(1.-p2),pl2,v^1,s);
|
||||
else dfs(pl1+1,p*p1,pl2,v^1,s),dfs(pl1,p*(1.-p1),pl2+1,v^1,s);
|
||||
}
|
||||
void dfs2(int l1,int l2,db pl1,db p,db pl2,int v){
|
||||
if(l1 == 3||l2 == 3){
|
||||
ans += p*(pl1+pl2);
|
||||
return ;
|
||||
}
|
||||
dfs2(l1+1,l2,pl1+win_num[v][0][0],dp[v][0][0]*p,pl2,0);
|
||||
dfs2(l1+1,l2,pl1+win_num[v][0][1],dp[v][0][1]*p,pl2,1);
|
||||
dfs2(l1,l2+1,pl1,dp[v][1][0]*p,pl2+win_num[v][1][0],0);
|
||||
dfs2(l1,l2+1,pl1,dp[v][1][1]*p,pl2+win_num[v][1][1],1);
|
||||
}
|
||||
char s[256];
|
||||
int main()
|
||||
{
|
||||
int T,cas = 1;
|
||||
int i,j,k;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s%s%lf",&s,&s,&p1);
|
||||
scanf("%s%s%lf",&s,&s,&p2);
|
||||
p1 /= 100.;
|
||||
p2 /= 100.;
|
||||
ans = 0.;
|
||||
for(i = 0; i < 2; i ++) for(j = 0; j < 2; j ++) for(k = 0; k < 2; k ++) win_num[i][j][k] = dp[i][j][k] = 0.;
|
||||
dfs(0,1.,0,0,0);
|
||||
dfs(0,1.,0,1,1);
|
||||
for(i = 0; i < 2; i ++) for(j = 0; j < 2; j ++) for(k = 0; k < 2; k ++) if(sign(dp[i][j][k])) win_num[i][j][k] /= dp[i][j][k];
|
||||
dfs2(0,0,0.,1.,0.,0);
|
||||
printf("Case #%d: %.6lf\n",cas++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
struct node{
|
||||
int id;
|
||||
int v;
|
||||
}p[33];
|
||||
bool cmp(node a,node b){
|
||||
return a.v<b.v;
|
||||
}
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
int ca=1;
|
||||
while(t--){
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
int i;
|
||||
int ans = 0;
|
||||
for(i=1;i<=n;i++){
|
||||
scanf("%d",&p[i].v);
|
||||
p[i].id = i;
|
||||
}
|
||||
sort(p+1,p+1+n,cmp);
|
||||
for(i=1;i<=n;i++){
|
||||
ans += abs(p[i].id-i);
|
||||
}
|
||||
printf("Case #%d: %d\n",ca++,ans/2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
__int64 dp[100][30][30];
|
||||
int ans[100];
|
||||
int main(){
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[0][1][0]=1;
|
||||
for(int i=2;i<=75;i++){
|
||||
for(int j=1;j<=27;j++){
|
||||
for(int k=0;k<=20;k++){
|
||||
__int64 val=0;
|
||||
if(j==1){
|
||||
if(k==0) continue;
|
||||
for(int jj=2;jj<=27;jj++){
|
||||
if(i>=j) val+=dp[i-j][jj][k-1];
|
||||
}
|
||||
}else{
|
||||
for(int jj=1;jj<=27;jj++){
|
||||
if(i>=j) val+=dp[i-j][jj][k];
|
||||
}
|
||||
}
|
||||
dp[i][j][k]=val;
|
||||
}
|
||||
}
|
||||
}
|
||||
int t,cas=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
int V,W;
|
||||
__int64 I;
|
||||
scanf("%d%d%I64d",&V,&W,&I);
|
||||
printf("Case #%d: ",++cas);
|
||||
W-=1;
|
||||
I-=1;
|
||||
ans[0]=-1;
|
||||
for(int i=2;i<=27;i++){
|
||||
if(I>=dp[V][i][W]){
|
||||
I-=dp[V][i][W];
|
||||
}else{
|
||||
V-=i;
|
||||
ans[0]=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ans[0]==-1){
|
||||
puts("Corrupted!");
|
||||
continue;
|
||||
}
|
||||
int cnt=1;
|
||||
bool flag=false;
|
||||
while(true){
|
||||
for(int i=1;i<=27;i++){
|
||||
if(flag&&(i==1)) continue;
|
||||
if((W==0)&&(i==1)) continue;
|
||||
flag=false;
|
||||
if(I>=dp[V][i][W]){
|
||||
I-=dp[V][i][W];
|
||||
}else{
|
||||
V-=i;
|
||||
if(i==1){W-=1;flag=true;}
|
||||
ans[cnt++]=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(V==0) break;
|
||||
}
|
||||
for(int i=0;i<cnt;i++){
|
||||
if(ans[i]==1) putchar(' ');
|
||||
else putchar(ans[i]-2+'a');
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
#define N 1000005
|
||||
#define LL long long
|
||||
int max(int a,int b){return a>b?a:b;}
|
||||
LL cnt[N];
|
||||
void gao(int n,int p){
|
||||
int i;
|
||||
int a=1;
|
||||
for(i=2;i*i<=n;i+=a,a=2){
|
||||
if(n%i==0){
|
||||
while(n%i==0){
|
||||
cnt[i] += p;
|
||||
n/=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(n>1)cnt[n] += p;
|
||||
}
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
int ca=1;
|
||||
while(t--){
|
||||
int n,m;
|
||||
scanf("%d%d",&n,&m);
|
||||
int i,j;
|
||||
int a,b;
|
||||
memset(cnt,0,sizeof(cnt));
|
||||
int maxm = 0;
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%d",&a);
|
||||
maxm = max(a,maxm);
|
||||
gao(a,1);
|
||||
}
|
||||
for(j=0;j<m;j++){
|
||||
scanf("%d",&b);
|
||||
maxm = max(b,maxm);
|
||||
gao(b,-1);
|
||||
}
|
||||
int x = 1,y = 1;
|
||||
for(i=2;i<=maxm;i++){
|
||||
if(cnt[i] > 0){
|
||||
while(cnt[i]--){
|
||||
x *= i;
|
||||
}
|
||||
} else if(cnt[i]<0){
|
||||
while(cnt[i]++){
|
||||
y *= i;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %d / %d\n",ca++,x,y);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define N 1000000
|
||||
char str[N];
|
||||
int x;
|
||||
int pow(int a,int b)
|
||||
{
|
||||
int res = 1;
|
||||
while(b--)
|
||||
res *= a;
|
||||
return res;
|
||||
}
|
||||
int solve()
|
||||
{
|
||||
int res = 0,add = 0,flag = 1,c,e;
|
||||
int i = 0,j = 0;
|
||||
int len = strlen(str);
|
||||
for(--len; str[len]!='+' && str[len] != '-' && len >= 0; --len);
|
||||
if(str[0] == '-')
|
||||
{
|
||||
flag = -1;
|
||||
i = 1;
|
||||
}
|
||||
for(;i < len; ++i)
|
||||
{
|
||||
c = 0;
|
||||
for(j = i; str[j] != 'X'; ++j)
|
||||
c = c*10 + str[j] - '0';
|
||||
if(i == j)
|
||||
c = 1;
|
||||
++j;
|
||||
if(str[j] == '^')
|
||||
{
|
||||
e = 0;
|
||||
for(++j;str[j] != '+' && str[j] !='-';++j)
|
||||
e = e * 10 + str[j] - '0';
|
||||
}
|
||||
else
|
||||
e = 1;
|
||||
res += c* flag*pow(x,e);
|
||||
if(str[j] == '+')
|
||||
flag = 1;
|
||||
else
|
||||
flag = -1;
|
||||
i = j;
|
||||
}
|
||||
c = 0;
|
||||
for(j = i;str[j] && str[j] != 'X'; ++j)
|
||||
c = c * 10 + str[j] - '0';
|
||||
if(!str[j])
|
||||
res += c * flag;
|
||||
else
|
||||
{
|
||||
if(i == j)
|
||||
c = 1;
|
||||
++j;
|
||||
if(!str[j])
|
||||
res += c * x * flag;
|
||||
else
|
||||
{
|
||||
++ j;
|
||||
e = 0;
|
||||
for(;str[j];++j)
|
||||
e = e * 10 + str[j] - '0';
|
||||
res += c * flag * pow(x,e);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,sp = 0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%s",&x,str);
|
||||
printf("Case #%d: %d\n",++sp, solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
#define N 1010
|
||||
int vis[N][N],height[N][N];
|
||||
int m,n,cnt;
|
||||
int mo[][2] = {0,1, 0,-1, 1,0, -1,0};
|
||||
bool ok(int x,int y,int c)
|
||||
{
|
||||
return x > 0 && x <= m && y > 0 && y <= n && height[x][y] >= c;
|
||||
}
|
||||
bool boundary(int x,int y)
|
||||
{
|
||||
return x == 1 || y == 1 || x == m || y == n;
|
||||
}
|
||||
void dfs(int x,int y,int c)
|
||||
{
|
||||
height[x][y] = 0;
|
||||
if(boundary(x,y))
|
||||
++cnt;
|
||||
int s,t;
|
||||
for(int i = 0; i < 4; ++i)
|
||||
{
|
||||
s = x + mo[i][0];
|
||||
t = y + mo[i][1];
|
||||
if(ok(s,t,c))
|
||||
dfs(s,t,height[s][t]);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,a;
|
||||
int x,y;
|
||||
int sp = 0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
int i,j;
|
||||
scanf("%d%d%d%d",&m,&n,&x,&y);
|
||||
for( i = 1 ; i <= m; ++i)
|
||||
for( j = 1 ; j <= n; ++j)
|
||||
scanf("%d",&height[i][j]);
|
||||
cnt = 0;
|
||||
dfs(x,y,height[x][y]);
|
||||
printf("Case #%d: %d\n",++sp,cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include<iostream>
|
||||
#include<string>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n, p=1;
|
||||
scanf("%d", &n);
|
||||
while(n--)
|
||||
{
|
||||
int a, b, c;
|
||||
scanf("%d%d%d", &a, &b, &c);
|
||||
if(a > b)
|
||||
swap(a, b);
|
||||
if(b > c)
|
||||
swap(b, c);
|
||||
if(a > b)
|
||||
swap(a, b);
|
||||
printf("Case #%d: ", p++);
|
||||
if(a+b <= c)
|
||||
printf("invalid!\n");
|
||||
else if(a==b && b==c)
|
||||
printf("equilateral\n");
|
||||
else if(a==b || b==c)
|
||||
printf("isosceles\n");
|
||||
else
|
||||
printf("scalene\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include"stdio.h"
|
||||
#include"math.h"
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
int t;
|
||||
int n;
|
||||
int x;
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
x=-1;
|
||||
t=(int)sqrt(n);
|
||||
for(i=t;i>0;i--)
|
||||
{
|
||||
if(n%i==0&&(n/i-i)%2==0&&(n/i-i)/2>0)
|
||||
{
|
||||
x=(n/i-i)/2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("%d\n",x);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
int num(char c)
|
||||
{
|
||||
if(c>='A' && c<='Z')
|
||||
return 0;
|
||||
else return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,i,k;
|
||||
char a[10005];
|
||||
while(~scanf("%d%s",&n,a))
|
||||
{
|
||||
for(i = 0;i<n;i+=5)
|
||||
{
|
||||
k = 0;
|
||||
if(num(a[i]))
|
||||
k+=16;
|
||||
if(num(a[i+1]))
|
||||
k+=8;
|
||||
if(num(a[i+2]))
|
||||
k+=4;
|
||||
if(num(a[i+3]))
|
||||
k+=2;
|
||||
if(num(a[i+4]))
|
||||
k++;
|
||||
printf("%c",k+'A');
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define N 100010
|
||||
struct enemy
|
||||
{
|
||||
int x, y, da, db;
|
||||
}p[N], c1, c2;
|
||||
bool cmp(enemy a, enemy b)
|
||||
{
|
||||
return a.da < b.da;
|
||||
}
|
||||
int dist(enemy a, enemy b)
|
||||
{
|
||||
return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase;
|
||||
int num;
|
||||
int ans, res, onlyb;
|
||||
scanf("%d", &ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
scanf("%d%d%d%d", &c1.x, &c1.y, &c2.x, &c2.y);
|
||||
scanf("%d", &num);
|
||||
for(int i = 0; i < num; ++i)
|
||||
{
|
||||
scanf("%d%d", &p[i].x, &p[i].y);
|
||||
p[i].da = dist(c1, p[i]);
|
||||
p[i].db = dist(c2, p[i]);
|
||||
}
|
||||
sort(p, p + num, cmp);
|
||||
res = p[num - 1].da;
|
||||
ans = 0;
|
||||
for(int i = num - 2; i >= 0; --i)
|
||||
{
|
||||
ans = max(ans, p[i + 1].db);
|
||||
res = min(res, ans + p[i].da);
|
||||
}
|
||||
ans = max(ans, p[0].db);
|
||||
res = min(res, ans);
|
||||
printf("%d\n", res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int main()
|
||||
{
|
||||
int s,n,m,x,y,i,j,count,sum=1;
|
||||
char str[1001][1001];
|
||||
int a[1001],b[1001];
|
||||
scanf("%d",&s);
|
||||
while(s--)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
memset(b,0,sizeof(b));
|
||||
count=0;
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",str[i]);
|
||||
}
|
||||
scanf("%d",&m);
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d %d",&x,&y);
|
||||
x--,y--;
|
||||
a[x]=1-a[x];
|
||||
b[y]=1-b[y];
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
if(a[i]+b[j]==1)
|
||||
{
|
||||
if(str[i][j]=='b') count++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(str[i][j]=='w') count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %d\n",sum++,count);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int main()
|
||||
{
|
||||
char str[10001];
|
||||
int s,b,d,f,F,i,j,len,sum,min;
|
||||
while(scanf("%d %d %d %d %d",&s,&b,&d,&f,&F)!=EOF)
|
||||
{
|
||||
min=99999;
|
||||
for(j=1;j<=s;j++)
|
||||
{
|
||||
sum=0;
|
||||
scanf("%s",str);
|
||||
len=strlen(str);
|
||||
for(i=0;i<=len-1;i++)
|
||||
{
|
||||
if(str[i]=='A')
|
||||
{
|
||||
sum=sum+b+d+f;
|
||||
}
|
||||
if(str[i]=='B')
|
||||
{
|
||||
sum=sum+2*b+2*d+F;
|
||||
}
|
||||
if(str[i]=='C')
|
||||
{
|
||||
sum=sum+3*b+3*d+2*F;
|
||||
}
|
||||
}
|
||||
if(min>sum) {min=sum;}
|
||||
}
|
||||
printf("%d\n",min);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
char s[31][10000];
|
||||
int main()
|
||||
{
|
||||
int n,i,j,len;
|
||||
s[1][0]='1';
|
||||
s[1][2]='\0';
|
||||
for(i=2;i<31;i++)
|
||||
{
|
||||
len=strlen(s[i-1]);
|
||||
int sum=1,k=0;
|
||||
for(j=0;j<len;j++)
|
||||
if(s[i-1][j+1]==s[i-1][j]) sum++;
|
||||
else
|
||||
{
|
||||
s[i][k]=sum+'0';
|
||||
k++;
|
||||
s[i][k]=s[i-1][j];
|
||||
k++;
|
||||
sum=1;
|
||||
}
|
||||
s[i][k]='\0';
|
||||
}
|
||||
while(cin>>n&&n)
|
||||
{
|
||||
len=strlen(s[n]);
|
||||
cout<<len<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int x[10];
|
||||
int main()
|
||||
{
|
||||
int m, p;
|
||||
int i;
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t--)
|
||||
{
|
||||
for (i=1; i<=9; i++) scanf("%d", &x[i]);
|
||||
m = 0;
|
||||
p = 0;
|
||||
int k=0;
|
||||
while(1)
|
||||
{
|
||||
for (i=1; i<=8; i++)
|
||||
{
|
||||
if (x[i]!=0) break;
|
||||
}
|
||||
p >>= 1;
|
||||
if (i>8 && p==0 && x[9]==0) break;
|
||||
int ct = 0;
|
||||
for (i=1; i<=8; i++)
|
||||
{
|
||||
if (x[i]&1) ct++;
|
||||
}
|
||||
int y = (ct&1);
|
||||
int z = ((x[9]&1)+(p&1))&1;
|
||||
int tm = y^z;
|
||||
if (tm)
|
||||
{
|
||||
p += (8-ct);
|
||||
}
|
||||
else
|
||||
{
|
||||
p += ct;
|
||||
}
|
||||
m += (tm<<k);
|
||||
k++;
|
||||
for (i=1; i<=9; i++) x[i]>>=1;
|
||||
}
|
||||
printf("%d\n", m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int main()
|
||||
{
|
||||
char a[1000001],b[100001];
|
||||
int s,i,j,p,count,len1,len2;
|
||||
scanf("%d",&s);
|
||||
while(s--)
|
||||
{
|
||||
count=0;
|
||||
scanf("%s %s",a,b);
|
||||
len1=strlen(a);
|
||||
len2=strlen(b);
|
||||
for(i=0;i<=len1-1;i++)
|
||||
{
|
||||
p=i;
|
||||
for(j=0;j<=len2-1;j++)
|
||||
{
|
||||
if(a[p]==b[j]) {p++;}
|
||||
else
|
||||
break;
|
||||
}
|
||||
if(j==len2)
|
||||
{
|
||||
count++;
|
||||
i=i+len2-1;
|
||||
}
|
||||
}
|
||||
printf("%d\n",count);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include"stdio.h"
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int t1[10];
|
||||
int ans;
|
||||
int i,j;
|
||||
int a,b,t;
|
||||
int num[10],k;
|
||||
int hash[10];
|
||||
int fac[10];
|
||||
fac[0]=1;
|
||||
for(i=1;i<10;i++) fac[i]=fac[i-1]*i;
|
||||
t1[0]=1;
|
||||
for(i=1;i<10;i++) t1[i]=9*fac[9]/fac[9-(i-1)];
|
||||
while(scanf("%d",&n)!=-1)
|
||||
{
|
||||
if(n<=0) {printf("0\n");continue;}
|
||||
if(n<10) {printf("%d\n",n-1);continue;}
|
||||
k=0;
|
||||
while(n)
|
||||
{
|
||||
num[k++]=n%10;
|
||||
n/=10;
|
||||
}
|
||||
a=0;
|
||||
b=k-1;
|
||||
while(a<b)
|
||||
{
|
||||
t=num[a];
|
||||
num[a]=num[b];
|
||||
num[b]=t;
|
||||
a++;
|
||||
b--;
|
||||
}
|
||||
ans=0;
|
||||
for(i=0;i<10;i++) hash[i]=1;
|
||||
for(i=1;i<k;i++) ans+=t1[i];
|
||||
ans+=(num[0]-1)*fac[9]/fac[10-k];
|
||||
hash[num[0]]=0;
|
||||
for(i=1;i<k;i++)
|
||||
{
|
||||
for(j=0;j<num[i];j++)
|
||||
{
|
||||
if(hash[j]) ans+=fac[9-i]/fac[10-k];
|
||||
}
|
||||
if(hash[num[i]]==0) break;
|
||||
hash[num[i]]=0;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
# include <cstdio>
|
||||
# include <cstring>
|
||||
int d[20]= {1},a[22][22],c[22],fn[22],n,m;
|
||||
int yes()
|
||||
{
|
||||
for (int i(1); i<=n; i++)
|
||||
{
|
||||
if (c[i]<fn[i]) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for (int i(1); i<=18; i++) d[i]=d[i-1]*2;
|
||||
while (scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for (int i(1); i<=n; i++) scanf("%d",&fn[i]);
|
||||
scanf("%d",&m);
|
||||
for (int i(1); i<=m; i++)
|
||||
{
|
||||
for (int j(1); j<=n; j++)
|
||||
{
|
||||
scanf("%d",&a[i][j]);
|
||||
}
|
||||
}
|
||||
int ans=0,ansi=0;
|
||||
for (int i(d[m+1]-1); i>=0; i--)
|
||||
{
|
||||
memset(c,0,sizeof(c));
|
||||
int num = 0;
|
||||
for (int j(1); j<=m; j++)
|
||||
{
|
||||
if (i&d[j-1])
|
||||
{
|
||||
num++;
|
||||
for (int k(1); k<=n; k++) c[k] += a[j][k];
|
||||
}
|
||||
}
|
||||
if (yes() && num >= ans)
|
||||
{
|
||||
ans = num;
|
||||
ansi = i;
|
||||
}
|
||||
}
|
||||
printf("%d",ans);
|
||||
for (int i(0); i<m; i++)
|
||||
{
|
||||
if (ansi & d[i]) printf(" %d",i+1);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include"stdio.h"
|
||||
#include"string.h"
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int i;
|
||||
int a[101];
|
||||
int mark[101];
|
||||
int s1,s2;
|
||||
int max;
|
||||
while(scanf("%d%d",&n,&m)!=-1,n||m)
|
||||
{
|
||||
memset(mark,0,sizeof(mark));
|
||||
max=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
mark[a[i]/m]++;
|
||||
if(max<a[i])max=a[i];
|
||||
}
|
||||
s2=max/m;
|
||||
max=0;
|
||||
for(i=0;i<=s2;i++)
|
||||
{
|
||||
if(mark[i]>max)
|
||||
max=mark[i];
|
||||
}
|
||||
s1=max;
|
||||
double ans;
|
||||
ans=0.01;
|
||||
for(i=0;i<=s2;i++)
|
||||
{
|
||||
ans+=(i*1.0/s2)*(mark[s2-i]*1.0/s1);
|
||||
}
|
||||
printf("%.6f\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
int f[1450]={0};
|
||||
int main()
|
||||
{
|
||||
int cmp(const void *a,const void *b);
|
||||
int t,i,max,p;
|
||||
while(scanf("%d",&t),t!=0)
|
||||
{
|
||||
max=0;
|
||||
p=0;
|
||||
for(i=0;i<t;i++)
|
||||
{
|
||||
scanf("%d",&f[i]);
|
||||
}
|
||||
qsort(f,t,sizeof(int),cmp);
|
||||
f[i]=1422;
|
||||
if((f[i]-f[i-1])>100)
|
||||
{
|
||||
printf("IMPOSSIBLE\n");
|
||||
p=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(i=1;i<t;i++)
|
||||
{
|
||||
if((f[i]-f[i-1])>max)
|
||||
{
|
||||
max=f[i]-f[i-1];
|
||||
if(max>200)
|
||||
{
|
||||
p=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(p==0)
|
||||
{
|
||||
printf("POSSIBLE\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("IMPOSSIBLE\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
return *(int *)a-* (int*)b;
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define MAXD 16000
|
||||
int sg[MAXD], h[7];
|
||||
char b[30];
|
||||
int dfs(int st)
|
||||
{
|
||||
if(sg[st] != -1)
|
||||
return sg[st];
|
||||
int i, j, k, s[10], sum = 0;
|
||||
memset(s, 0, sizeof(s));
|
||||
for(i = 1; i <= 6; i ++)
|
||||
sum += h[i] * i;
|
||||
for(i = 1; i <= 6; i ++)
|
||||
if(h[i] < 4 && i + sum <= 31)
|
||||
{
|
||||
++ h[i];
|
||||
for(j = 1, k = 0; j <= 6; j ++)
|
||||
k = k * 5 + h[j];
|
||||
s[dfs(k)] = 1;
|
||||
-- h[i];
|
||||
}
|
||||
for(i = 0; s[i]; i ++);
|
||||
return sg[st] = i;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i, j, k, turn;
|
||||
memset(h, 0, sizeof(h));
|
||||
for(i = 0; b[i]; i ++)
|
||||
++ h[b[i] - '0'];
|
||||
turn = i % 2;
|
||||
for(i = 1, j = 0; i <= 6; i ++)
|
||||
j = j * 5 + h[i];
|
||||
k = dfs(j);
|
||||
printf("%s ", b);
|
||||
if(turn == 0)
|
||||
printf("%s\n", k == 0 ? "B" : "A");
|
||||
else
|
||||
printf("%s\n", k == 0 ? "A" : "B");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
memset(sg, -1, sizeof(sg));
|
||||
while(scanf("%s", b) == 1)
|
||||
{
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
#include <cstdio>
|
||||
int main(){
|
||||
for(int a,b,c,t;scanf("%d%d%d",&a,&b,&c)&&(a||b||c);){
|
||||
if(a<b)t=a,a=b,b=t;
|
||||
if(a<c)t=a,a=c,c=t;
|
||||
printf("%s\n",(a+b>c)&&(a+c>b)&&(b+c>a)&&a*a==b*b+c*c?"right":"wrong");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int map[21][21];
|
||||
bool vis[21][21];
|
||||
int dx[4]= {1,-1,0,0};
|
||||
int dy[4]= {0,0,-1,1};
|
||||
int cb,cw,n;
|
||||
struct point
|
||||
{
|
||||
int x,y;
|
||||
}p,t;
|
||||
void bfs(int x,int y)
|
||||
{
|
||||
p.x=x,p.y=y;
|
||||
queue <point> q;
|
||||
q.push(p);
|
||||
int num=0;
|
||||
vis[p.x][p.y]=true;
|
||||
int r2=-1,r3=-1;
|
||||
while(!q.empty())
|
||||
{
|
||||
t=q.front();
|
||||
num++;
|
||||
q.pop();
|
||||
for(int i=0; i<4; i++)
|
||||
{
|
||||
p.x=t.x+dx[i];
|
||||
p.y=t.y+dy[i];
|
||||
if(vis[p.x][p.y]) continue;
|
||||
if(p.x<1||p.x>n||p.y<1||p.y>n) continue;
|
||||
if(map[p.x][p.y]==1) r2=1;
|
||||
else if(map[p.x][p.y]==2) r3=1;
|
||||
else q.push(p),vis[p.x][p.y]=true;
|
||||
}
|
||||
}
|
||||
if(r2==1&&r3==1) return ;
|
||||
if(r3==-1) cb+=num;
|
||||
else if(r2==-1) cw+=num;
|
||||
return ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int b,w,x,y;
|
||||
while(scanf("%d",&n)==1&&n)
|
||||
{
|
||||
memset(map,0,sizeof(map));
|
||||
memset(vis,false,sizeof(vis));
|
||||
cb=cw=0;
|
||||
scanf("%d%d",&b,&w);
|
||||
for(int i=0; i<b; i++)
|
||||
scanf("%d%d",&x,&y),map[x][y]=1;
|
||||
for(int i=0; i<w; i++)
|
||||
scanf("%d%d",&x,&y),map[x][y]=2;
|
||||
for(int i=1; i<=n; i++)
|
||||
for(int j=1; j<=n; j++)
|
||||
if(!map[i][j]&&!vis[i][j]) bfs(i,j);
|
||||
if(cb==cw) printf("Draw\n");
|
||||
else if(cb>cw) printf("Black wins by %d\n",cb-cw);
|
||||
else printf("White wins by %d\n",cw-cb);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include"stdio.h"
|
||||
#include"math.h"
|
||||
double jie(int n)
|
||||
{
|
||||
double y=1;
|
||||
int i;
|
||||
for(i=2;i<=n;i++)
|
||||
y*=i;
|
||||
return y;
|
||||
}
|
||||
double c(int n,int x)
|
||||
{
|
||||
double z;
|
||||
z=jie(n)/jie(x)/jie(n-x);
|
||||
return z;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double ans;
|
||||
int n;
|
||||
int s;
|
||||
double x,y;
|
||||
int i;
|
||||
while(scanf("%d%d",&n,&s)!=-1)
|
||||
{
|
||||
if(s>n)
|
||||
{
|
||||
printf("100.00000\n");
|
||||
continue;
|
||||
}
|
||||
x=y=0;
|
||||
for(i=0;i<s;i++)
|
||||
x+=c(n,i)*pow(2,n-i);
|
||||
for(i=0;i<=s;i++)
|
||||
y+=c(n,i)*pow(2,n-i);
|
||||
ans=x/y;
|
||||
printf("%0.5lf\n",ans*100);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#define max 510
|
||||
struct d
|
||||
{
|
||||
int w,l,h;
|
||||
}doll[max];
|
||||
int match[max][max];
|
||||
int link[max];
|
||||
bool used[max];
|
||||
int n;
|
||||
bool dfs(int u)
|
||||
{
|
||||
for(int v=1;v<=n;v++)
|
||||
if(match[u][v]==1&&!used[v])
|
||||
{
|
||||
used[v]=true;
|
||||
if(link[v]==-1||dfs(link[v]))
|
||||
{
|
||||
link[v]=u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int Xiong()
|
||||
{
|
||||
int res=0;
|
||||
memset(link,-1,sizeof(link));
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
memset(used,false,sizeof(used));
|
||||
if(dfs(i))
|
||||
res++;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(scanf("%d",&n)==1&&n)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d%d%d",&doll[i].w,&doll[i].l,&doll[i].h);
|
||||
memset(match,0,sizeof(match));
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
if(doll[i].w>doll[j].w&&doll[i].l>doll[j].l&&doll[i].h>doll[j].h)
|
||||
match[i][j]=1;
|
||||
printf("%d\n",n-Xiong());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <stdio.h>
|
||||
int sum=-1;
|
||||
int dif(int a[],int n)
|
||||
{
|
||||
int i,s=0;
|
||||
bool zero=true;
|
||||
sum++;
|
||||
for(i=0;i<n-1;i++)
|
||||
{ if(a[i]<0)
|
||||
a[i]=0-a[i];
|
||||
if(a[i+1]<0)
|
||||
a[i+1]=0-a[i+1];
|
||||
a[i]=a[i+1]-a[i];
|
||||
if(a[i]!=0)
|
||||
zero=false;
|
||||
s+=a[i];
|
||||
}
|
||||
a[n-1]=s;
|
||||
if(s==0 && zero)
|
||||
return sum;
|
||||
if(sum>1000)
|
||||
return -1;
|
||||
dif(a,n);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a[21];
|
||||
int n,temp=1;
|
||||
while(scanf("%d",&n)!=EOF && n)
|
||||
{
|
||||
sum=-1;
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
int num=dif(a,n);
|
||||
printf("Case %d: ",temp);
|
||||
if(num==-1)
|
||||
printf("not attained\n");
|
||||
else
|
||||
printf("%d iterations\n",num);
|
||||
temp++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
int b[300100],len;
|
||||
char c[300100];
|
||||
inline int ca(int x)
|
||||
{return x<len?x:x-len;}
|
||||
int minp()
|
||||
{
|
||||
int i=0,j=1,k=0;
|
||||
while(i<len && j<len && k<len)
|
||||
{
|
||||
int det=b[ca(i+k)]-b[ca(j+k)];
|
||||
if(det==0) k++;
|
||||
else
|
||||
{
|
||||
if(det>0) i+=k+1; else j+=k+1;
|
||||
if(i==j) j++;
|
||||
k=0;
|
||||
}
|
||||
}
|
||||
return i>j?j:i;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%s",c)==1)
|
||||
{
|
||||
len=strlen(c);c[len]=c[0];c[len+1]='\0';
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
b[i]=c[i+1]-c[i];
|
||||
if(c[i]>c[i+1]) b[i]+=8;
|
||||
}
|
||||
int k=minp();
|
||||
for(int l=0;l<len;l++) printf("%d",b[ca(k+l)]); puts("");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef struct
|
||||
{
|
||||
int p,d;
|
||||
}Data;
|
||||
Data dt[1000003];
|
||||
bool cmp1(Data d1,Data d2)
|
||||
{
|
||||
if(d1.p==d2.p) return d1.d<d2.d;
|
||||
return d1.p<d2.p;
|
||||
}
|
||||
bool cmp2(Data d1,Data d2)
|
||||
{
|
||||
if(d1.p==d2.p) return d1.d>d2.d;
|
||||
return d1.p>d2.p;
|
||||
}
|
||||
bool cmp3(Data d1,Data d2)
|
||||
{
|
||||
return d1.d<d2.d;
|
||||
}
|
||||
bool cmp4(Data d1,Data d2)
|
||||
{
|
||||
return d1.d>d2.d;
|
||||
}
|
||||
void print()
|
||||
{
|
||||
static int cnt=0;
|
||||
printf("Case %d\n",++cnt);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,k1,k2;
|
||||
while(scanf("%d %d %d",&n,&k1,&k2),n&&k1&&k2)
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&dt[i].p);
|
||||
dt[i].d=i+1;
|
||||
}
|
||||
sort(dt,dt+n,cmp1);
|
||||
print();
|
||||
sort(dt,dt+k1,cmp3);
|
||||
printf("%d",dt[0].d);
|
||||
for(int i=1;i<k1;i++)
|
||||
printf(" %d",dt[i].d);
|
||||
printf("\n");
|
||||
sort(dt,dt+n,cmp2);
|
||||
sort(dt,dt+k2,cmp4);
|
||||
printf("%d",dt[0].d);
|
||||
for(int i=1;i<k2;i++)
|
||||
printf(" %d",dt[i].d);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
#include<cstdlib>
|
||||
#include<ctime>
|
||||
#include<cmath>
|
||||
#include<bitset>
|
||||
using namespace std;
|
||||
#define N 210
|
||||
#define inf 50000000
|
||||
int dir[8][2] = { { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 },
|
||||
{ -1, -1 }, { -1, 0 }, { -1, 1 } };
|
||||
int T = 1, n, m, idx, tot;
|
||||
int maz[N][N], done[N * N], ans[N * N];
|
||||
char Map[N][N];
|
||||
struct position {
|
||||
int x, y;
|
||||
} u, v, qu[N * N];
|
||||
void bfs(int x, int y) {
|
||||
maz[x][y] = idx;
|
||||
Map[x][y] = '0';
|
||||
u.x = x;
|
||||
u.y = y;
|
||||
int l = 0, r = 1;
|
||||
qu[0] = u;
|
||||
while (l < r) {
|
||||
u = qu[l++];
|
||||
for (int i = 0; i < 8; i++) {
|
||||
v.x = u.x + dir[i][0];
|
||||
v.y = u.y + dir[i][1];
|
||||
if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m
|
||||
&& Map[v.x][v.y] == '1') {
|
||||
maz[v.x][v.y] = idx;
|
||||
Map[v.x][v.y] = '0';
|
||||
qu[r++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (r < 5)
|
||||
done[idx] = 1;
|
||||
}
|
||||
void solve(int x, int y) {
|
||||
u.x = x;
|
||||
u.y = y;
|
||||
int i = 1, to = 6;
|
||||
qu[0] = u;
|
||||
for (;;) {
|
||||
int flag = 0;
|
||||
for (int j = to; j != to || !flag; j = (j + 1) % 8) {
|
||||
if (j == to)
|
||||
flag = 1;
|
||||
v.x = u.x + dir[j][0];
|
||||
v.y = u.y + dir[j][1];
|
||||
if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m
|
||||
&& maz[v.x][v.y] == maz[x][y]) {
|
||||
u.x = u.x + dir[(j + 7) % 8][0];
|
||||
u.y = u.y + dir[(j + 7) % 8][1];
|
||||
for (j = 0; j < 8; j++) {
|
||||
if (v.x + dir[j][0] == u.x && v.y + dir[j][1] == u.y) {
|
||||
to = j;
|
||||
break;
|
||||
}
|
||||
}
|
||||
qu[i++] = v;
|
||||
u = v;
|
||||
if (i >= 4 && qu[0].x == qu[i - 2].x && qu[0].y == qu[i - 2].y
|
||||
&& qu[1].x == qu[i - 1].x && qu[1].y == qu[i - 1].y) {
|
||||
ans[tot++] = i - 2;
|
||||
return;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
while (~scanf("%d%d", &n, &m)) {
|
||||
if (!n && !m)
|
||||
break;
|
||||
for (int i = 1; i <= n; i++)
|
||||
scanf("%s", Map[i] + 1);
|
||||
idx = 0;
|
||||
memset(maz, 0, sizeof(maz));
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 1; j <= m; j++) {
|
||||
if (Map[i][j] == '1') {
|
||||
idx++;
|
||||
done[idx] = 0;
|
||||
bfs(i, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
tot = 0;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 1; j <= m; j++) {
|
||||
if (maz[i][j] && !done[maz[i][j]]) {
|
||||
done[maz[i][j]] = 1;
|
||||
solve(i, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d\n", T++);
|
||||
if (tot) {
|
||||
sort(ans, ans + tot);
|
||||
for (int i = 0; i < tot; i++)
|
||||
printf("%d%s", ans[i], (i == tot - 1) ? "\n" : " ");
|
||||
} else
|
||||
printf("no objects found\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<stack>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define clr(x) memset(x,0,sizeof(x))
|
||||
long long dp[31][31];
|
||||
bool inti(){
|
||||
clr(dp);
|
||||
for(int i=0;i<=30;i++){
|
||||
dp[i][0]=1;
|
||||
}
|
||||
for(int i=1;i<=30;i++){
|
||||
for(int j=1;j<=i;j++){
|
||||
dp[i][j]=dp[i-1][j]+dp[i][j-1];
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int main(){
|
||||
inti();
|
||||
int i,j,k,m,n;
|
||||
while(cin>>n&&n){
|
||||
cout<<dp[n][n]<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
const int maxn = 1005;
|
||||
const int inf = 1<<29;
|
||||
struct nd{
|
||||
int x,y,d,t,id;
|
||||
};
|
||||
int has[maxn][maxn][4];
|
||||
int ans[maxn][maxn][4];
|
||||
int vis[maxn][maxn][4];
|
||||
int dx[] = {0,-1,0,1};
|
||||
int dy[] = {1,0,-1,0};
|
||||
char as[maxn][maxn],E[10],dd[128];
|
||||
int N,M,m,mn,cnt;
|
||||
int si,sj,di,dj;
|
||||
bool nok(int x,int y){
|
||||
if(x<0||y<0||x==N||y==M||as[x][y]=='*')return true;
|
||||
return false;
|
||||
}
|
||||
void bfs(int x,int y,int d)
|
||||
{
|
||||
nd k,t;
|
||||
int a,b,c,i;
|
||||
cnt = 0;
|
||||
for(a = 0; a < N; ++ a)
|
||||
for(b = 0; b < M; ++ b)
|
||||
for(c = 0; c < 4; ++ c)
|
||||
has[a][b][c]=inf,ans[a][b][c]=0;
|
||||
has[x][y][d]=0; ans[x][y][d]=1;
|
||||
if(x==di&&y==dj)return;
|
||||
queue<nd>que;
|
||||
t.x=x;t.y=y;t.d=d;t.t=0; t.id = cnt; vis[x][y][d]=cnt++;
|
||||
que.push(t);
|
||||
while(!que.empty()){
|
||||
t = que.front(); que.pop();
|
||||
if(t.id ^ vis[t.x][t.y][t.d])continue;
|
||||
for(i = 0; i < 4; ++ i){
|
||||
k = t; k.t++; k.d = i;
|
||||
k.x += dx[i]; k.y += dy[i];
|
||||
if(nok(k.x,k.y))continue;
|
||||
if(i^t.d)k.t++;
|
||||
if((i+2)%4==t.d)k.t++;
|
||||
if(k.t>has[k.x][k.y][k.d]||k.t>mn)continue;
|
||||
if(k.t==has[k.x][k.y][k.d]){
|
||||
ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
|
||||
if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
|
||||
if((i+2)%4==t.d){
|
||||
ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
|
||||
if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
|
||||
}
|
||||
}else{
|
||||
ans[k.x][k.y][k.d]=ans[t.x][t.y][t.d];
|
||||
if((i+2)%4==t.d)ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
|
||||
if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
|
||||
}
|
||||
has[k.x][k.y][k.d] = k.t;
|
||||
if(k.x==di && k.y==dj){
|
||||
if(has[k.x][k.y][k.d]<mn)mn=has[k.x][k.y][k.d];
|
||||
continue;
|
||||
}
|
||||
k.id = cnt; vis[k.x][k.y][k.d] = cnt++;
|
||||
que.push(k);
|
||||
}
|
||||
ans[t.x][t.y][t.d]=0;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas=0,i,k;
|
||||
dd['E']=0;dd['N']=1;dd['W']=2;dd['S']=3;
|
||||
while(scanf("%d %d %d",&N,&M,&m)!=EOF){
|
||||
if(!m)break;
|
||||
for(i = 0; i < N; ++ i)
|
||||
scanf("%s",as[i]);
|
||||
scanf("%d %d %d %d %s",&si,&sj,&di,&dj,E);
|
||||
mn = inf;
|
||||
bfs(si,sj,dd[E[0]]);
|
||||
k = 0;
|
||||
for(i = 0; i < 4; ++ i){
|
||||
if(has[di][dj][i]<mn){
|
||||
mn = has[di][dj][i];
|
||||
k = ans[di][dj][i];
|
||||
}else if(has[di][dj][i]==mn){
|
||||
k += ans[di][dj][i];
|
||||
if(k >= m)k -= m;
|
||||
}
|
||||
}
|
||||
if(mn==inf)printf("Case %d: %d -1\n",++cas,m);
|
||||
else printf("Case %d: %d %d\n",++cas,m,k);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<iostream>
|
||||
#include<sstream>
|
||||
#include<algorithm>
|
||||
#include<set>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
cin.sync_with_stdio(false);
|
||||
int n,maxlen,cas=1;
|
||||
while(cin>>n>>maxlen)
|
||||
{
|
||||
if(n==0&&maxlen==0) break;
|
||||
cout<<"Case "<<cas++<<endl;
|
||||
string s,a,b,ss;
|
||||
set<string>myset;
|
||||
getline(cin,s);
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
getline(cin,ss);
|
||||
for(int j=0;j<ss.length();j++)
|
||||
while(ss[j]==39||ss[j]==45) ss.erase(j,1);
|
||||
istringstream oss(ss);
|
||||
oss>>a;while(oss>>b);
|
||||
s=a[0]+b;
|
||||
for(int i=0;i<s.length();i++) s[i]=tolower(s[i]);
|
||||
string add;int id=1;
|
||||
if(s.length()>maxlen) s.erase(maxlen);
|
||||
while(myset.find(s+add)!=myset.end())
|
||||
{
|
||||
add.clear();
|
||||
if(id>9) add+=48+id/10;add+=48+id%10;
|
||||
if(add.length()+s.length()>maxlen)
|
||||
s.erase(maxlen-add.length());
|
||||
id++;
|
||||
}
|
||||
myset.insert(s+add);cout<<s+add<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
const int N = 150010;
|
||||
vector<int> g[N];
|
||||
int n,dp[310],K,w[N];
|
||||
void init()
|
||||
{
|
||||
for(int i=0;i<=n;i++)
|
||||
g[i].clear();
|
||||
}
|
||||
int dfs(int u)
|
||||
{
|
||||
int size=g[u].size();
|
||||
int t=0;
|
||||
int cur[310];
|
||||
for(int i=1;i<=K;i++)
|
||||
dp[i]=cur[i]=-INT_MAX;
|
||||
cur[0]=dp[0]=0;
|
||||
for(int i=0;i<size;i++)
|
||||
{
|
||||
int v=g[u][i];
|
||||
int now=dfs(v);
|
||||
for(int j=t;j>=0;j--)
|
||||
{
|
||||
for(int k=1;k<=now;k++)
|
||||
{
|
||||
if(k+j>K)
|
||||
break;
|
||||
cur[k+j]=max(cur[k+j],dp[k]+cur[j]);
|
||||
}
|
||||
}
|
||||
t+=now;
|
||||
}
|
||||
if(size==0)
|
||||
t++;
|
||||
cur[1]=max(cur[1],w[u]);
|
||||
for(int i=0;i<=K;i++)
|
||||
dp[i]=cur[i];
|
||||
return t;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int x,root;
|
||||
while(scanf("%d %d",&n,&K)==2)
|
||||
{
|
||||
init();
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d %d",&x,&w[i]);
|
||||
if(x==0)
|
||||
root=i;
|
||||
else
|
||||
g[x].push_back(i);
|
||||
}
|
||||
dfs(root);
|
||||
if(dp[K]==-INT_MAX)
|
||||
printf("impossible\n");
|
||||
else printf("%d\n",dp[K]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#define eps 1e-6
|
||||
using namespace std;
|
||||
struct point
|
||||
{
|
||||
int x,y;
|
||||
}a[10],v[10],s;
|
||||
double t,ans;
|
||||
int N,sv,i,p[10],T[3],js=1;
|
||||
double crosstime(double x0,double y0,double v0,double x1,double y1,double vx,double vy)
|
||||
{
|
||||
double a,b,c,t;
|
||||
a=vx*vx+vy*vy-v0*v0;
|
||||
b=2*(vx*(x1-x0)+vy*(y1-y0));
|
||||
c=(x1-x0)*(x1-x0)+(y1-y0)*(y1-y0);
|
||||
if(a<eps&&a>-eps) return -c/b;
|
||||
if(a<eps) {a=-a;b=-b;c=-c;}
|
||||
return (-b+sqrt(b*b-4*a*c))/(2*a);
|
||||
}
|
||||
double back(double x0,double y0,double x1,double y1,double sv)
|
||||
{
|
||||
return sqrt((x1-x0)*(x1-x0)+(y1-y0)*(y1-y0))/sv;
|
||||
}
|
||||
void trs(double ans,int T[3])
|
||||
{
|
||||
T[0]=(int)ans;
|
||||
ans-=T[0];
|
||||
T[1]=(int)(ans*=60.0);ans-=T[1];
|
||||
T[2]=(int)(ans*60.0+0.9999999);
|
||||
if(T[2]==60) {T[2]=0;T[1]++;}
|
||||
if(T[1]==60) {T[1]=0;T[0]++;}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&N),N)
|
||||
{
|
||||
for(i=0;i<N;i++) scanf("%d%d%d%d",&a[i].x,&a[i].y,&v[i].x,&v[i].y);
|
||||
scanf("%d%d%d",&s.x,&s.y,&sv);
|
||||
for(i=0;i<=N;i++) p[i]=i;
|
||||
ans=1e9;
|
||||
do
|
||||
{
|
||||
t=crosstime(s.x*1.0,s.y*1.0,sv*1.0,a[p[0]].x,a[p[0]].y,v[p[0]].x,v[p[0]].y)+1.0;
|
||||
for(i=1;i<N;i++)
|
||||
t+=1.0+crosstime(a[p[i-1]].x*1.0+t*v[p[i-1]].x,a[p[i-1]].y*1.0+t*v[p[i-1]].y,sv*1.0,a[p[i]].x*1.0+t*v[p[i]].x,a[p[i]].y*1.0+t*v[p[i]].y,v[p[i]].x*1.0,v[p[i]].y*1.0);
|
||||
t+=back(a[p[N-1]].x*1.0+t*v[p[N-1]].x,a[p[N-1]].y*1.0+t*v[p[N-1]].y,s.x,s.y,sv);
|
||||
if(t<ans) ans=t;
|
||||
}
|
||||
while(next_permutation(p,p+N));
|
||||
trs(ans,T);
|
||||
printf("Case %d: %d hour(s) %d minute(s) %d second(s)\n",js++,T[0],T[1],T[2]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int N = 100010;
|
||||
__int64 num[N],dis[N],num1 = 0,head[N];
|
||||
struct edge
|
||||
{
|
||||
int rp,value,next;
|
||||
}ee[N];
|
||||
void init()
|
||||
{
|
||||
num1 = 0;
|
||||
memset(num,0,sizeof(num));
|
||||
memset(dis,0,sizeof(dis));
|
||||
memset(head,-1,sizeof(head));
|
||||
}
|
||||
void addedge(int x,int y,int v)
|
||||
{
|
||||
ee[num1].rp = y;
|
||||
ee[num1].value = v;
|
||||
ee[num1].next = head[x];
|
||||
head[x] = num1++;
|
||||
}
|
||||
void bfs(int x)
|
||||
{
|
||||
queue<int> qq;
|
||||
qq.push(x);
|
||||
while(!qq.empty())
|
||||
{
|
||||
int y = qq.front();
|
||||
qq.pop();
|
||||
for(int i = head[y];i != -1;i = ee[i].next)
|
||||
{
|
||||
int k = ee[i].rp;
|
||||
dis[k] = dis[y] + ee[i].value;
|
||||
qq.push(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
init();
|
||||
for(int i = 0;i <= n;++i)
|
||||
{
|
||||
scanf("%I64d",&num[i]);
|
||||
}
|
||||
int x,y,value;
|
||||
__int64 sum = 0;
|
||||
for(int i = 1;i <= n;++i)
|
||||
{
|
||||
scanf("%d%d%d",&x,&y,&value);
|
||||
addedge(x,y,value);
|
||||
sum += value;
|
||||
}
|
||||
bfs(0);
|
||||
__int64 mmin = 2000000000;
|
||||
__int64 ss = 0;
|
||||
for(int i = 0;i <= n;++i)
|
||||
{
|
||||
ss = (sum - dis[i]) * 2 + num[i] + dis[i];
|
||||
if(ss < mmin)
|
||||
{
|
||||
mmin = ss;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",mmin);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<iostream>
|
||||
#include<sstream>
|
||||
#include<fstream>
|
||||
#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;
|
||||
const int maxn = 200 +5;
|
||||
pair<double,double>con[maxn];
|
||||
int main(){
|
||||
int n;
|
||||
while(cin >> n){
|
||||
for(int i = 1 ; i <= n ; i++) scanf("%lf%lf",&con[i].first,&con[i].second);
|
||||
int ans = 0;
|
||||
for(int i = 1 ; i <= n ; i++){
|
||||
for(int j = 1 ; j <= n ; j++){
|
||||
pair<double,double> t;
|
||||
t.first = (con[i].first + con[j].first) / 2.0;
|
||||
t.second = (con[i].second + con[j].second) / 2.0;
|
||||
int cnt = 0;
|
||||
for(int k = 1 ; k <= n ; k++){
|
||||
double dis = pow(t.first - con[k].first,2) + pow(t.second - con[k].second,2);
|
||||
if(dis <= 6.25 + eps) cnt++;
|
||||
}
|
||||
ans = max(ans , cnt);
|
||||
}
|
||||
}
|
||||
cout << ans << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int main()
|
||||
{
|
||||
int n,len,num[111],flag,k,b,i;
|
||||
char a[111];
|
||||
scanf("%d",&n);
|
||||
while(n--)
|
||||
{
|
||||
flag=0;
|
||||
scanf("%s",a);
|
||||
len=strlen(a);
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(a[i]=='a'||a[i]=='b'||a[i]=='c'||a[i]=='A'||a[i]=='B'||a[i]=='C')
|
||||
num[i]=2;
|
||||
else if(a[i]=='d'||a[i]=='e'||a[i]=='f'||a[i]=='D'||a[i]=='E'||a[i]=='F')
|
||||
num[i]=3;
|
||||
else if(a[i]=='g'||a[i]=='h'||a[i]=='i'||a[i]=='G'||a[i]=='H'||a[i]=='I')
|
||||
num[i]=4;
|
||||
else if(a[i]=='j'||a[i]=='k'||a[i]=='l'||a[i]=='J'||a[i]=='K'||a[i]=='L')
|
||||
num[i]=5;
|
||||
else if(a[i]=='m'||a[i]=='n'||a[i]=='o'||a[i]=='M'||a[i]=='N'||a[i]=='O')
|
||||
num[i]=6;
|
||||
else if(a[i]=='p'||a[i]=='q'||a[i]=='r'||a[i]=='s'||a[i]=='P'||a[i]=='Q'||a[i]=='R'||a[i]=='S')
|
||||
num[i]=7;
|
||||
else if(a[i]=='t'||a[i]=='u'||a[i]=='v'||a[i]=='T'||a[i]=='U'||a[i]=='V')
|
||||
num[i]=8;
|
||||
else if(a[i]=='w'||a[i]=='x'||a[i]=='y'||a[i]=='z'||a[i]=='W'||a[i]=='X'||a[i]=='Y'||a[i]=='Z')
|
||||
num[i]=9;
|
||||
}
|
||||
k=0;
|
||||
b=len-1;
|
||||
while(k<b)
|
||||
{
|
||||
if(num[k]!=num[b])
|
||||
{
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
k++;
|
||||
b--;
|
||||
}
|
||||
}
|
||||
if(flag==1)
|
||||
{
|
||||
printf("NO\n");
|
||||
}
|
||||
else
|
||||
printf("YES\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <cstdio>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
struct point
|
||||
{
|
||||
int pos,value;
|
||||
}pp[27][1010];
|
||||
int dp[27][1010];
|
||||
int main()
|
||||
{
|
||||
int numcase;
|
||||
scanf("%d",&numcase);
|
||||
for(int k = 1;k <= numcase;++k)
|
||||
{
|
||||
int numl,numc,len,i,j,p;
|
||||
memset(dp,0,sizeof(dp));
|
||||
scanf("%d%d%d",&numl,&numc,&len);
|
||||
for(i = 1;i <= numl;++i)
|
||||
{
|
||||
for(j = 1;j <= numc;++j)
|
||||
{
|
||||
scanf("%d%d",&pp[i][j].pos,&pp[i][j].value);
|
||||
}
|
||||
}
|
||||
int mmin = 200000000;
|
||||
for(i = 1;i <= numl;++i)
|
||||
{
|
||||
for(j = 1;j <= numc;++j)
|
||||
{
|
||||
mmin = 200000000;
|
||||
for(p = 1;p <= numc;++p)
|
||||
{
|
||||
dp[i][j] = dp[i-1][p] + abs(pp[i][j].pos - pp[i-1][p].pos) + pp[i][j].value;
|
||||
if(dp[i][j] < mmin)
|
||||
{
|
||||
mmin = dp[i][j];
|
||||
}
|
||||
}
|
||||
dp[i][j] = mmin;
|
||||
}
|
||||
}
|
||||
mmin = 200000000;
|
||||
for( i = 1;i <= numc;++i)
|
||||
{
|
||||
dp[numl][i] = dp[numl][i] + abs(len - pp[numl][i].pos);
|
||||
if(dp[numl][i] < mmin)
|
||||
{
|
||||
mmin = dp[numl][i];
|
||||
}
|
||||
}
|
||||
printf("%d\n",mmin);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int k;
|
||||
int n;
|
||||
cin>>k;
|
||||
int a[55];
|
||||
int cas=1;
|
||||
while(k--)
|
||||
{
|
||||
cin>>n;
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
int b,c,d=-1;
|
||||
sort(a,a+n);
|
||||
printf("Class %d\n",cas++);
|
||||
b=a[0],c=a[n-1];
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
d=max(d,a[i]-a[i-1]);
|
||||
}
|
||||
printf("Max %d, Min %d, Largest gap %d\n",c,b,d);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <stdio.h>
|
||||
inline int ab(int x) { return x >= 0 ? x : -x ;}
|
||||
int cal(int x,int y,int z,int &k)
|
||||
{
|
||||
if(ab(x-y)==ab(y-z)) {
|
||||
k = y; return ab(x-y);
|
||||
}
|
||||
else if(ab(x-z)==ab(y-z)) {
|
||||
k = z; return ab(x-z);
|
||||
}
|
||||
else if(ab(x-y)==ab(z-x)) {
|
||||
k = x; return ab(x-y);
|
||||
}
|
||||
else { k = -1 ; return -1;}
|
||||
}
|
||||
int tx[8] , ti[8];
|
||||
int h[4] , m[4] , re[4];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int re[4] , dis;
|
||||
for(int i=1;i<=3;i++){
|
||||
scanf("%d:%d",&h[i],&m[i]);
|
||||
}
|
||||
for(int i=1;i<=3;i++)
|
||||
{
|
||||
re[i] = h[i]*60+m[i];
|
||||
}
|
||||
int ok = 0;
|
||||
tx[1] = cal(re[1],re[2],re[3],ti[1]);
|
||||
tx[2] = cal(re[1]+720,re[2],re[3],ti[2]);
|
||||
tx[3] = cal(re[1],re[2]+720,re[3],ti[3]);
|
||||
tx[4] = cal(re[1],re[2],re[3]+720,ti[4]);
|
||||
tx[5] = cal(re[1]-720,re[2],re[3],ti[5]);
|
||||
tx[6] = cal(re[1],re[2]-720,re[3],ti[6]);
|
||||
tx[7] = cal(re[1],re[2],re[3]-720,ti[7]);
|
||||
for(int i=1;i<=7;i++)
|
||||
{
|
||||
if(tx[i] > 0)
|
||||
{
|
||||
ok = 1;
|
||||
if(tx[i] == 4*60) {
|
||||
printf("Look at the sun\n");
|
||||
break;
|
||||
}
|
||||
else {
|
||||
printf("The correct time is %d:%02d\n",
|
||||
ti[i]/60,ti[i]%60);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!ok) printf("Look at the sun\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
int main()
|
||||
{
|
||||
char inf[50],ans[5];
|
||||
int t,n,cnt,cas = 0,f,i,j,y[5];
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
memset(y,0,sizeof(y));
|
||||
gets(inf);
|
||||
for(j = 0; j < n; ++j)
|
||||
{
|
||||
cnt = f = 0;
|
||||
gets(inf);
|
||||
for(i = 0; inf[i] != ' ' && inf[i]; ++i);
|
||||
for(; inf[i]; ++i){
|
||||
if(inf[i-1] == ' ' && inf[i] == 'y'){
|
||||
if(cnt == 0)
|
||||
++y[1];
|
||||
else
|
||||
++y[2];
|
||||
++cnt;
|
||||
f = 1;
|
||||
}
|
||||
else if(inf[i-1] ==' ' && inf[i] =='n'){
|
||||
++cnt;
|
||||
}
|
||||
}
|
||||
if(cnt == 0)
|
||||
++y[4];
|
||||
else if(!f)
|
||||
++y[3];
|
||||
}
|
||||
printf("Roll-call: %d\n",++cas);
|
||||
printf("Present: %d out of %d\n",y[1],n);
|
||||
printf("Needs to study at home: %d out of %d\n",y[2],n);
|
||||
printf("Needs remedial work after school: %d out of %d\n",y[3],n);
|
||||
printf("Absent: %d out of %d\n",y[4],n);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int N = 11111;
|
||||
const int M = 55555;
|
||||
int eh[2][N], ec[2];
|
||||
struct Edge {
|
||||
int id, nx, df;
|
||||
double l;
|
||||
Edge() {}
|
||||
Edge(int id, int nx, int df, double l) : id(id), nx(nx), df(df), l(l) {}
|
||||
} edge[2][M << 1];
|
||||
inline void init() {
|
||||
memset(eh, -1, sizeof(eh));
|
||||
memset(ec, 0, sizeof(ec));
|
||||
}
|
||||
inline void addedge(int u, int v, int df, double l, int id) {
|
||||
edge[id][ec[id]] = Edge(v, eh[id][u], df, l);
|
||||
eh[id][u] = ec[id]++;
|
||||
}
|
||||
int x[N], y[N], z[N];
|
||||
template<class T> inline T sqr(T a) { return a * a;}
|
||||
int st[M << 1], ed[M << 1];
|
||||
inline int getdf(int a, int b) {
|
||||
if (z[a] >= z[b]) return 0;
|
||||
double len = sqrt(sqr((double) x[a] - x[b]) + sqr((double) y[a] - y[b]));
|
||||
return (int) floor(100.0 * (z[b] - z[a]) / len);
|
||||
}
|
||||
inline double getdis(int a , int b) { return sqrt(sqr((double) x[a] - x[b]) + sqr((double) y[a] - y[b]) + sqr((double) z[a] - z[b]));}
|
||||
const double FINF = 1e50;
|
||||
double dis[2][N];
|
||||
int q[M << 1];
|
||||
bool vis[N];
|
||||
void spfa(int s, int id) {
|
||||
for (int i = 0; i < N; i++) dis[id][i] = FINF;
|
||||
int qh, qt;
|
||||
qh = qt = 0;
|
||||
dis[id][s] = 0;
|
||||
q[qt++] = s;
|
||||
vis[s] = true;
|
||||
while (qh < qt) {
|
||||
int cur = q[qh++];
|
||||
vis[cur] = false;
|
||||
for (int i = eh[id][cur]; ~i; i = edge[id][i].nx) {
|
||||
if (dis[id][edge[id][i].id] > dis[id][cur] + edge[id][i].l) {
|
||||
dis[id][edge[id][i].id] = dis[id][cur] + edge[id][i].l;
|
||||
if (!vis[edge[id][i].id]) q[qt++] = edge[id][i].id, vis[edge[id][i].id] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int n, m;
|
||||
while (~scanf("%d%d", &n, &m) && (n || m)) {
|
||||
for (int i = 1; i <= n; i++) scanf("%d%d%d", &x[i], &y[i], &z[i]);
|
||||
for (int i = 0; i < m; i++) scanf("%d%d", &st[i], &ed[i]);
|
||||
int A, B, D;
|
||||
scanf("%d%d%d", &A, &B, &D);
|
||||
init();
|
||||
for (int i = 0; i < m; i++) {
|
||||
double tmp = getdis(st[i], ed[i]);
|
||||
int df = getdf(st[i], ed[i]);
|
||||
if (df <= D) {
|
||||
addedge(st[i], ed[i], df, tmp, 0);
|
||||
addedge(ed[i], st[i], df, tmp, 1);
|
||||
}
|
||||
df = getdf(ed[i], st[i]);
|
||||
if (df <= D) {
|
||||
addedge(ed[i], st[i], df, tmp, 0);
|
||||
addedge(st[i], ed[i], df, tmp, 1);
|
||||
}
|
||||
}
|
||||
spfa(A, 0);
|
||||
spfa(B, 1);
|
||||
double ans = FINF;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int t = eh[0][i]; ~t; t = edge[0][t].nx) {
|
||||
if (edge[0][t].df == D) ans = min(ans, dis[0][i] + edge[0][t].l + dis[1][edge[0][t].id]);
|
||||
}
|
||||
}
|
||||
if (ans < FINF) printf("%.1f\n", ans);
|
||||
else puts("None");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include <stdio.h>
|
||||
#define EPS 1e-20
|
||||
__int64 exgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
|
||||
{
|
||||
if(b == 0LL)
|
||||
{
|
||||
x = 1LL;
|
||||
y = 0LL;
|
||||
return a;
|
||||
}
|
||||
__int64 d = exgcd(b,a%b,x,y);
|
||||
__int64 t = x;
|
||||
x = y;
|
||||
y = t - a / b * y;
|
||||
return d;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
__int64 t,a,b,x,y,c1,d1,c2,d2,d;
|
||||
scanf("%I64d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%I64d/%I64d",&a,&b);
|
||||
x = y = 0;
|
||||
d = exgcd(a,b,x,y);
|
||||
if(d != 1)
|
||||
{
|
||||
printf("%I64d/%I64d\n",a/d,b/d);
|
||||
continue;
|
||||
}
|
||||
if(a == 1)
|
||||
{
|
||||
printf("1/%I64d\n",b-1);
|
||||
continue;
|
||||
}
|
||||
while(x < 0)
|
||||
x += b;
|
||||
d1 = x;
|
||||
c1 = (a * d1 - 1LL) / b;
|
||||
while(y < 0)
|
||||
y += a;
|
||||
c2 = y;
|
||||
d2 = (b * c2 - 1LL) / a;
|
||||
if(d1 > d2)
|
||||
printf("%I64d/%I64d\n",c1,d1);
|
||||
else
|
||||
printf("%I64d/%I64d\n",c2,d2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
using namespace std ;
|
||||
#define maxn 201
|
||||
#define INF 10000000
|
||||
struct node
|
||||
{
|
||||
int e , d ;
|
||||
}qe[maxn] ;
|
||||
int dp[maxn][maxn] , k ;
|
||||
int cmp( node a , node b )
|
||||
{
|
||||
return a.d > b.d ;
|
||||
}
|
||||
bool check( int n , int m )
|
||||
{
|
||||
int i , j ;
|
||||
for( i = 0 ; i <= n ;i++ )
|
||||
for( j = 0 ; j <= m ;j++ )
|
||||
dp[i][j] = INF ;
|
||||
dp[0][0] = 0 ;
|
||||
for( i = 1 ; i <= n ;i++ )
|
||||
{
|
||||
dp[i][0] = dp[i-1][0]+qe[i].e ;
|
||||
for( j = 1 ; j <= m && j <= i;j++ )
|
||||
{
|
||||
dp[i][j] = dp[i-1][j]+qe[i].e ;
|
||||
dp[i][j] = min( dp[i][j],dp[i-1][j-1]+j*qe[i].d) ;
|
||||
}
|
||||
}
|
||||
return dp[n][m] <= k ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i , j , n , m ,ans ,case1 = 0 , tot ;
|
||||
while( scanf("%d%d",&n , &k ) != EOF)
|
||||
{
|
||||
if( n == k && k == 0 ) break ;
|
||||
tot = 0 ;
|
||||
for( i = 1 ; i <= n ;i++ ) {
|
||||
scanf("%d%d" , &qe[i].e,&qe[i].d) ;
|
||||
tot += qe[i].e ;
|
||||
}
|
||||
sort(qe+1,qe+1+n,cmp) ;
|
||||
ans = -1 ;
|
||||
if( tot <= k ) ans = 0 ;
|
||||
for( i = n ; i >= 0 ;i-- )
|
||||
{
|
||||
if(check(n,i))
|
||||
{
|
||||
ans = i ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if( ans == -1 )printf("%d: Mission Impossible\n",++case1) ;
|
||||
else printf("%d: %d\n",++case1,ans) ;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int head[10000], s, t, nv, maxint=99999999, cnt;
|
||||
int cur[400], num[400], d[400], q[100000], pre[400];
|
||||
struct Node
|
||||
{
|
||||
double q;
|
||||
int x, y, r;
|
||||
}dian[1000];
|
||||
int cmp(Node x, Node y)
|
||||
{
|
||||
return x.q<y.q;
|
||||
}
|
||||
struct node
|
||||
{
|
||||
int u, v, cap, next;
|
||||
}edge[100000];
|
||||
void add(int u, int v, int cap)
|
||||
{
|
||||
edge[cnt].v=v;
|
||||
edge[cnt].cap=cap;
|
||||
edge[cnt].next=head[u];
|
||||
head[u]=cnt++;
|
||||
edge[cnt].v=u;
|
||||
edge[cnt].cap=0;
|
||||
edge[cnt].next=head[v];
|
||||
head[v]=cnt++;
|
||||
}
|
||||
void bfs()
|
||||
{
|
||||
memset(num,0,sizeof(num));
|
||||
memset(d,-1,sizeof(d));
|
||||
int f1=0, f2=0, i;
|
||||
q[f1++]=t;
|
||||
d[t]=0;
|
||||
num[0]=1;
|
||||
while(f1>=f2)
|
||||
{
|
||||
int u=q[f2++];
|
||||
for(i=head[u];i!=-1;i=edge[i].next)
|
||||
{
|
||||
int v=edge[i].v;
|
||||
if(d[v]==-1)
|
||||
{
|
||||
d[v]=d[u]+1;
|
||||
num[d[v]]++;
|
||||
q[f1++]=v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void isap()
|
||||
{
|
||||
memcpy(cur,head,sizeof(cur));
|
||||
bfs();
|
||||
int flow=0, u=pre[s]=s, i;
|
||||
while(d[s]<nv)
|
||||
{
|
||||
if(u==t)
|
||||
{
|
||||
int f=maxint, pos;
|
||||
for(i=s;i!=t;i=edge[cur[i]].v)
|
||||
{
|
||||
if(f>edge[cur[i]].cap)
|
||||
{
|
||||
f=edge[cur[i]].cap;
|
||||
pos=i;
|
||||
}
|
||||
}
|
||||
for(i=s;i!=t;i=edge[cur[i]].v)
|
||||
{
|
||||
edge[cur[i]].cap-=f;
|
||||
edge[cur[i]^1].cap+=f;
|
||||
}
|
||||
flow+=f;
|
||||
u=pos;
|
||||
}
|
||||
for(i=cur[u];i!=-1;i=edge[i].next)
|
||||
{
|
||||
if(d[edge[i].v]+1==d[u]&&edge[i].cap)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(i!=-1)
|
||||
{
|
||||
cur[u]=i;
|
||||
pre[edge[i].v]=u;
|
||||
u=edge[i].v;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(--num[d[u]]==0) break;
|
||||
int mind=nv;
|
||||
for(i=head[u];i!=-1;i=edge[i].next)
|
||||
{
|
||||
if(mind>d[edge[i].v]&&edge[i].cap)
|
||||
{
|
||||
cur[u]=i;
|
||||
mind=d[edge[i].v];
|
||||
}
|
||||
}
|
||||
d[u]=mind+1;
|
||||
num[d[u]]++;
|
||||
u=pre[u];
|
||||
}
|
||||
}
|
||||
if(flow>=2)
|
||||
printf("Game is VALID\n");
|
||||
else
|
||||
printf("Game is NOT VALID\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, j, n, x, y, r, T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
cnt=0;
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%lf%d%d%d",&dian[i].q,&dian[i].x,&dian[i].y,&dian[i].r);
|
||||
}
|
||||
sort(dian,dian+n,cmp);
|
||||
if(dian[0].r+dian[n-1].r*1.0>sqrt((dian[0].x-dian[n-1].x)*(dian[0].x-dian[n-1].x)*1.0+(dian[0].y-dian[n-1].y)*(dian[0].y-dian[n-1].y)*1.0))
|
||||
{
|
||||
printf("Game is VALID\n");
|
||||
continue ;
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=i+1;j<n;j++)
|
||||
{
|
||||
if(dian[i].r*1.0+dian[j].r>sqrt((dian[i].x-dian[j].x)*(dian[i].x-dian[j].x)+(dian[i].y-dian[j].y)*(dian[i].y-dian[j].y)))
|
||||
{
|
||||
add(i,j,1);
|
||||
}
|
||||
}
|
||||
}
|
||||
s=0;
|
||||
t=n-1;
|
||||
nv=t+1;
|
||||
isap();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include<stdio.h>
|
||||
#include<vector>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int map[700][700],p[700][700],vis[700],x[700],y[700],t,n,num,k;
|
||||
char s[700][700];
|
||||
bool search(int i)
|
||||
{
|
||||
int j;
|
||||
for(j=0;j<num;j++)
|
||||
{
|
||||
if(map[i][j]&&!vis[j])
|
||||
{
|
||||
vis[j]=1;
|
||||
if(!y[j]||search(y[j]))
|
||||
{
|
||||
y[j]=i;
|
||||
x[i]=j;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int match()
|
||||
{
|
||||
memset(x,0,sizeof(x));
|
||||
memset(y,0,sizeof(y));
|
||||
int ans=0;
|
||||
for(int i=0;i<num;i++)
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
if(search(i)) ans++;
|
||||
}
|
||||
return ans/2;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&t);
|
||||
k=1;
|
||||
while(t--)
|
||||
{
|
||||
int i,j;
|
||||
num=0;
|
||||
memset(map,0,sizeof(map));
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%s",s[i]);
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
if(s[i][j]=='#')
|
||||
p[i][j]=num++;
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
if(s[i][j]=='#')
|
||||
{
|
||||
if(j<n-1&&s[i][j+1]=='#')
|
||||
{
|
||||
map[p[i][j]][p[i][j+1]]=1;
|
||||
map[p[i][j+1]][p[i][j]]=1;
|
||||
}
|
||||
if(i<n-1&&s[i+1][j]=='#')
|
||||
{
|
||||
map[p[i][j]][p[i+1][j]]=1;
|
||||
map[p[i+1][j]][p[i][j]]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int p=match();
|
||||
printf("Case %d: %d\n",k++,p);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
#define MOD 100000007
|
||||
#define PRIME_SIZE 500005
|
||||
#define _int64 long long
|
||||
using namespace std;
|
||||
int prime[PRIME_SIZE], phi[PRIME_SIZE];
|
||||
bool primes[PRIME_SIZE];
|
||||
void Euler_primes_phi_mu()
|
||||
{
|
||||
phi[1]=1;
|
||||
for (int i=2; i<PRIME_SIZE; i++)
|
||||
{
|
||||
if (primes[i]==0)
|
||||
phi[i]=i-1, prime[++prime[0]]=i;
|
||||
for (int j=1; j<=prime[0] && prime[j]*i<PRIME_SIZE; j++)
|
||||
{
|
||||
primes[prime[j]*i]=true;
|
||||
if (i%prime[j]==0) { phi[i*prime[j]] = phi[i]*prime[j]; break; }
|
||||
phi[i*prime[j]] = phi[i]*(prime[j]-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
_int64 GCD(_int64 a, _int64 b) { for (_int64 t; a%b; t=a%b, a=b, b=t) ; return b; }
|
||||
_int64 pow_mod(_int64 a, _int64 n)
|
||||
{
|
||||
_int64 ans=1;
|
||||
for (; n; n>>=1, a=(a*a)%MOD) if (n&1) ans=(ans*a)%MOD;
|
||||
return ans;
|
||||
}
|
||||
_int64 polay(int n, int base)
|
||||
{
|
||||
_int64 ans=0;
|
||||
for (int i=1; i*i<=n; i++)
|
||||
if (n%i==0)
|
||||
{
|
||||
ans=(ans+pow_mod(base, i)*phi[n/i])%MOD;
|
||||
if (i*i!=n)
|
||||
ans=(ans+pow_mod(base, n/i)*phi[i])%MOD;
|
||||
}
|
||||
ans=(ans*pow_mod(n, MOD-2))%MOD;
|
||||
return ans;
|
||||
}
|
||||
int ne[PRIME_SIZE], N[PRIME_SIZE], d[PRIME_SIZE];
|
||||
void Pre_next(int *s, int len)
|
||||
{
|
||||
int i, j=0;
|
||||
for (ne[0]=-1, i=2; i<=len; i++)
|
||||
{
|
||||
while (j>-1 && s[i-1]!=s[j]) j=ne[j];
|
||||
ne[i]=++j;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Euler_primes_phi_mu();
|
||||
int n, m, i;
|
||||
while (scanf("%d %d", &m, &n), ~m)
|
||||
{
|
||||
for (i=1; i<=n; i++) scanf("%d", &N[i]);
|
||||
sort(N+1, N+n+1); N[n+1]=N[1]+360000;
|
||||
for (i=1; i<=n; i++) d[i-1]=N[i+1]-N[i];
|
||||
Pre_next(d, n);
|
||||
int dif=n-ne[n];
|
||||
_int64 gcd;
|
||||
if (n%dif==0) gcd=GCD(n, dif);
|
||||
else gcd=n;
|
||||
_int64 ans=polay(n/gcd, pow_mod(m, gcd));
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 100010
|
||||
#define M 260010
|
||||
typedef long long LL;
|
||||
struct node{
|
||||
LL x,y;
|
||||
int id;
|
||||
}w[150010];
|
||||
LL ty[150010],ans[100010];
|
||||
int ny;
|
||||
struct Tree{
|
||||
int l,r;
|
||||
LL val;
|
||||
}tree[1050010];
|
||||
bool cmp1(const node &a,const node &b){
|
||||
if(a.x!=b.x) return a.x<b.x;
|
||||
if(a.y!=b.y) return a.y<b.y;
|
||||
return a.id<b.id;
|
||||
}
|
||||
bool cmp2(const node &a,const node &b){
|
||||
if(a.x!=b.x) return a.x<b.x;
|
||||
if(a.y!=b.y) return a.y>b.y;
|
||||
return a.id<b.id;
|
||||
}
|
||||
bool cmp3(const node &a,const node &b){
|
||||
if(a.x!=b.x) return a.x>b.x;
|
||||
if(a.y!=b.y) return a.y<b.y;
|
||||
return a.id<b.id;
|
||||
}
|
||||
bool cmp4(const node &a,const node &b){
|
||||
if(a.x!=b.x) return a.x>b.x;
|
||||
if(a.y!=b.y) return a.y>b.y;
|
||||
return a.id<b.id;
|
||||
}
|
||||
int findy(LL y){
|
||||
int l=0,r=ny-1;
|
||||
while(l<=r){
|
||||
int mid=(l+r)>>1;
|
||||
if(ty[mid]<y) l=mid+1;
|
||||
else if(ty[mid]>y) r=mid-1;
|
||||
else return mid+1;
|
||||
}
|
||||
}
|
||||
void build(int L,int R,int x){
|
||||
tree[x].l=L;
|
||||
tree[x].r=R;
|
||||
tree[x].val=1000000000000;
|
||||
if(L==R) return ;
|
||||
int mid=(L+R)>>1;
|
||||
build(L,mid,x<<1);
|
||||
build(mid+1,R,x<<1|1);
|
||||
}
|
||||
LL find(int L,int R,int x){
|
||||
if(tree[x].l>=L&&tree[x].r<=R)
|
||||
return tree[x].val;
|
||||
int mid=(tree[x].l+tree[x].r)>>1;
|
||||
if(R<=mid) return find(L,R,x<<1);
|
||||
if(L>mid) return find(L,R,x<<1|1);
|
||||
return min(find(L,mid,x<<1),find(mid+1,R,x<<1|1));
|
||||
}
|
||||
void update(int id,int x,LL val){
|
||||
if(tree[x].l==tree[x].r){
|
||||
tree[x].val=min(tree[x].val,val);
|
||||
return ;
|
||||
}
|
||||
int mid=(tree[x].l+tree[x].r)>>1;
|
||||
if(id<=mid) update(id,x<<1,val);
|
||||
else update(id,x<<1|1,val);
|
||||
tree[x].val=min(tree[x<<1].val,tree[x<<1|1].val);
|
||||
}
|
||||
int main(){
|
||||
int n,q,cs=0;
|
||||
while(scanf("%d",&n)&&n!=-1){
|
||||
if(cs) printf("\n");
|
||||
else cs=1;
|
||||
for(int i=0;i<n;++i){
|
||||
scanf("%lld%lld",&w[i].x,&w[i].y);
|
||||
w[i].id=-1;
|
||||
ty[i]=w[i].y;
|
||||
}
|
||||
scanf("%d",&q);
|
||||
for(int i=0;i<q;++i){
|
||||
ans[i]=1000000000000;
|
||||
scanf("%lld%lld",&w[i+n].x,&w[i+n].y);
|
||||
w[i+n].id=i;
|
||||
ty[i+n]=w[i+n].y;
|
||||
}
|
||||
sort(ty,ty+n+q);
|
||||
ny=0;
|
||||
for(int i=1;i<n+q;++i)
|
||||
if(ty[i]!=ty[ny]) ty[++ny]=ty[i];
|
||||
ny++;
|
||||
LL my=ty[ny-1],iy=ty[0];
|
||||
build(1,ny,1);
|
||||
sort(w,w+n+q,cmp1);
|
||||
LL mx=w[n+q-1].x,ix=w[0].x;
|
||||
for(int i=0;i<n+q;++i){
|
||||
if(w[i].id!=-1){
|
||||
int j=findy(w[i].y);
|
||||
ans[w[i].id]=min(ans[w[i].id],find(1,j,1)-(my-w[i].y)-(mx-w[i].x));
|
||||
}
|
||||
else update(findy(w[i].y),1,(my-w[i].y)+(mx-w[i].x));
|
||||
}
|
||||
build(1,ny,1);
|
||||
sort(w,w+n+q,cmp2);
|
||||
for(int i=0;i<n+q;++i){
|
||||
if(w[i].id!=-1){
|
||||
int j=findy(w[i].y);
|
||||
ans[w[i].id]=min(ans[w[i].id],find(j,ny,1)-(w[i].y-iy)-(mx-w[i].x));
|
||||
}
|
||||
else update(findy(w[i].y),1,(w[i].y-iy)+(mx-w[i].x));
|
||||
}
|
||||
build(1,ny,1);
|
||||
sort(w,w+n+q,cmp3);
|
||||
for(int i=0;i<n+q;++i){
|
||||
if(w[i].id!=-1){
|
||||
int j=findy(w[i].y);
|
||||
ans[w[i].id]=min(ans[w[i].id],find(1,j,1)-(my-w[i].y)-(w[i].x-ix));
|
||||
}
|
||||
else update(findy(w[i].y),1,(my-w[i].y)+(w[i].x-ix));
|
||||
}
|
||||
build(1,ny,1);
|
||||
sort(w,w+n+q,cmp4);
|
||||
for(int i=0;i<n+q;++i){
|
||||
if(w[i].id!=-1){
|
||||
int j=findy(w[i].y);
|
||||
ans[w[i].id]=min(ans[w[i].id],find(j,ny,1)-(w[i].y-iy)-(w[i].x-ix));
|
||||
}
|
||||
else update(findy(w[i].y),1,(w[i].y-iy)+(w[i].x-ix));
|
||||
}
|
||||
for(int i=0;i<q;++i) printf("%lld\n",ans[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
#define size 500010
|
||||
using namespace std;
|
||||
int n,m;
|
||||
int a[size];
|
||||
int ok(int x)
|
||||
{
|
||||
int i = 0 , t = 0;
|
||||
while ( i < n)
|
||||
{
|
||||
t += ceil(a[i]*1.0 / x );
|
||||
i++;
|
||||
}
|
||||
if(t > m) return 0;
|
||||
else return 1;
|
||||
}
|
||||
int find_ans(int low , int heigh)
|
||||
{
|
||||
int mid , ans;
|
||||
while (low < heigh)
|
||||
{
|
||||
mid = (low + heigh) /2;
|
||||
int temp = ok(mid);
|
||||
if( ok(mid) == 0 ) { low = mid + 1; }
|
||||
else { heigh = mid ;}
|
||||
}
|
||||
return heigh;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int max;
|
||||
while ( scanf("%d%d",&n,&m) != EOF && n!=-1 && m!=-1)
|
||||
{
|
||||
int avg = m/n;
|
||||
max = 0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
if(a[i] > max) max = a[i];
|
||||
}
|
||||
if( n == m ) printf("%d\n",max);
|
||||
else
|
||||
printf("%d\n",find_ans(1, max));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#define DB double
|
||||
using namespace std;
|
||||
const int MAXN = 20;
|
||||
DB dp[MAXN][MAXN];
|
||||
void init(){
|
||||
for(int i = 0;i <= 10; i++)
|
||||
for(int j = 0; j <= 10; j++)
|
||||
dp[i][j] = 0.0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
DB p;
|
||||
while(scanf("%lf",&p) != EOF){
|
||||
if(p == -1.0) break;
|
||||
init();
|
||||
for(int i = 0; i < 3; i++) dp[4][i] = 1.0;
|
||||
dp[3][3] = p * p / (1 - p * (1 - p) * 2);
|
||||
for(int i = 3; i >= 0; i--)
|
||||
for(int j = 3; j >= 0;j--){
|
||||
if(i == 3 && j == 3) continue;
|
||||
dp[i][j] = p * dp[i+1][j] + (1 - p) * dp[i][j + 1];
|
||||
}
|
||||
DB gp = dp[0][0];
|
||||
init();
|
||||
for(int i = 0; i < 6; i++) dp[7][i] = 1.0;
|
||||
dp[6][6] = p * p / (1 - p * (1 - p) * 2);
|
||||
for(int i = 6; i >= 0; i--)
|
||||
for(int j = 6; j >= 0;j--){
|
||||
if(i == 6 && j == 6) continue;
|
||||
dp[i][j] = p * dp[i+1][j] + (1 - p) * dp[i][j + 1];
|
||||
}
|
||||
DB p7 = dp[0][0];
|
||||
init();
|
||||
dp[6][6] = p7;
|
||||
dp[6][5] = gp + (1.0 - gp) * dp[6][6];
|
||||
dp[5][6] = gp * dp[6][6];
|
||||
for(int i = 0; i <= 4;i++) dp[6][i] = 1.0;
|
||||
for(int i = 5; i >= 0; i--)
|
||||
for(int j = 5;j >= 0;j--){
|
||||
dp[i][j] = gp * dp[i+1][j] + (1.0 - gp) * dp[i][j+1];
|
||||
}
|
||||
DB sp = dp[0][0];
|
||||
init();
|
||||
for(int i = 0; i < 2; i++) dp[2][i] = 1.0;
|
||||
for(int i = 1; i >= 0; i--)
|
||||
for(int j = 1; j >= 0; j--){
|
||||
dp[i][j] = dp[i+1][j] * sp + dp[i][j+1] * (1.0 - sp);
|
||||
}
|
||||
DB mp = dp[0][0];
|
||||
printf("%.11f %.11f %.11f\n",gp,sp,mp);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 10005
|
||||
char str[N];
|
||||
int num[N];
|
||||
char op[N];
|
||||
int v[11];
|
||||
int id[11];
|
||||
char cmp(char a,char b){
|
||||
if(a=='+'){
|
||||
if(b=='+' || b=='-' || b==')')return '>';
|
||||
else return '<';
|
||||
}
|
||||
if(a=='-'){
|
||||
if(b=='+' || b=='-' || b==')')return '>';
|
||||
else return '<';
|
||||
}
|
||||
if(a=='*'){
|
||||
if(b=='(')return '<';
|
||||
else return '>';
|
||||
}
|
||||
if(a=='('){
|
||||
if(b==')')return '=';
|
||||
else return '<';
|
||||
}
|
||||
if(a==')'){
|
||||
return '>';
|
||||
}
|
||||
}
|
||||
int cal(int a,int b,char c){
|
||||
if(c=='+')return a+b;
|
||||
if(c=='-')return a-b;
|
||||
if(c=='*')return a*b;
|
||||
}
|
||||
int gao(){
|
||||
int i,j;
|
||||
int topnum = 0,topop = 1;
|
||||
int k = 1;
|
||||
op[1] = '(';
|
||||
for(i=1;str[i];i++){
|
||||
if(islower(str[i])){
|
||||
topnum++;
|
||||
num[topnum] = v[id[k++]];
|
||||
} else {
|
||||
char c = cmp(op[topop],str[i]);
|
||||
char tag;
|
||||
if(c=='<'){
|
||||
topop++;
|
||||
op[topop] = str[i];
|
||||
} else if(c=='='){
|
||||
topop--;
|
||||
} else if(c=='>'){
|
||||
int b = num[topnum--];
|
||||
int a = num[topnum--];
|
||||
tag = op[topop--];
|
||||
int res = cal(a,b,tag);
|
||||
topnum++;
|
||||
num[topnum] = res;
|
||||
i--;
|
||||
}
|
||||
}
|
||||
}
|
||||
return num[topnum];
|
||||
}
|
||||
int main(){
|
||||
int n;
|
||||
while(scanf("%d",&n) && n){
|
||||
int i,j;
|
||||
for(i=1;i<=n;i++){
|
||||
scanf("%d",&v[i]);
|
||||
id[i] = i;
|
||||
}
|
||||
int ans;
|
||||
scanf("%d",&ans);
|
||||
scanf("%s",str+1);
|
||||
int len = strlen(str+1);
|
||||
str[0] = '(',str[len+1] = ')',str[len+2] = '\0';
|
||||
bool ok =0;
|
||||
do{
|
||||
int tmp = gao();
|
||||
if(tmp==ans){
|
||||
ok = 1;
|
||||
break;
|
||||
}
|
||||
}while(next_permutation(id+1,id+1+n));
|
||||
if(ok)puts("YES");
|
||||
else puts("NO");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include"iostream"
|
||||
#include"cstdio"
|
||||
#include"cstring"
|
||||
using namespace std;
|
||||
const int N=1000006;
|
||||
int n,num[N],ans;
|
||||
int main()
|
||||
{
|
||||
int i,l;
|
||||
int p,acc,sum,cnt;
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
sum=0;
|
||||
for(i=0;i<n;i++){scanf("%d",&num[i]);sum+=num[i];}
|
||||
if(sum<0) {printf("0\n");continue;}
|
||||
p=n-1;
|
||||
ans=cnt=sum=0;
|
||||
while(cnt<=p)
|
||||
{
|
||||
sum+=num[cnt++];
|
||||
while(sum<0) sum+=num[p--];
|
||||
}
|
||||
acc=0;
|
||||
while(p>=0)
|
||||
{
|
||||
if(acc>=0) ans++;
|
||||
if(acc<0) acc+=num[p];
|
||||
else if(num[p]<0) acc=num[p];
|
||||
p--;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#define MP(a, b) make_pair(a, b)
|
||||
#define PB(a) push_back(a)
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
typedef pair<int, int> pii;
|
||||
typedef pair<unsigned int,unsigned int> puu;
|
||||
typedef pair<int, double> pid;
|
||||
typedef pair<ll, int> pli;
|
||||
typedef pair<int, ll> pil;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const double eps = 1E-6;
|
||||
const int LEN = 1001;
|
||||
map<string, int> mp;
|
||||
int n, k, top;
|
||||
int num[LEN];
|
||||
vector<int> tab[LEN];
|
||||
int ch(string s){
|
||||
if(!mp.count(s)) mp[s] = top++;
|
||||
return mp[s];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char str[1010];
|
||||
int tmp;
|
||||
while(scanf("%d%d", &k, &n) != EOF){
|
||||
if(!k && !n) break;
|
||||
for(int i=0; i<LEN; i++) tab[i].clear();
|
||||
top = 0; mp.clear();
|
||||
for(int i=0; i<n; i++){
|
||||
scanf("%s", &str);
|
||||
num[i] = ch(str);
|
||||
for(int j=0; j<k; j++){
|
||||
scanf("%d", &tmp);
|
||||
tmp --;
|
||||
tab[tmp].PB(i);
|
||||
}
|
||||
}
|
||||
int ans = 0;
|
||||
for(int i=0; i<n; i++){
|
||||
if(tab[i].size() != k) ans ++;
|
||||
else{
|
||||
map<int, int> st;
|
||||
int cc = 0;
|
||||
for(int j=0; j<tab[i].size(); j++){
|
||||
int x = tab[i][j], y = num[i];
|
||||
if(num[x] == y || st.count(x)){
|
||||
ans ++;break;
|
||||
}else st[x] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ans == 0) puts("NO PROBLEMS FOUND");
|
||||
else if(ans == 1) puts("1 PROBLEM FOUND");
|
||||
else printf("%d PROBLEMS FOUND\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<cmath>
|
||||
#define eps 1e-6
|
||||
#define pi acos(-1)
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
double x,y;
|
||||
};
|
||||
node p[4];
|
||||
double getdis(node p1,node p2)
|
||||
{
|
||||
return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
|
||||
}
|
||||
double getang(double a,double b,double c)
|
||||
{
|
||||
double ang= (a*a+b*b-c*c)/(2*a*b);
|
||||
return acos(ang);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char str[1000];
|
||||
while(gets(str)&&strcmp(str,"END")!=0)
|
||||
{
|
||||
sscanf(str,"%lf%lf",&p[0].x,&p[0].y);
|
||||
scanf("%lf%lf%lf%lf",&p[1].x,&p[1].y,&p[2].x,&p[2].y);
|
||||
getchar();
|
||||
double dis1=getdis(p[0],p[1]);
|
||||
double dis2=getdis(p[1],p[2]);
|
||||
double dis3=getdis(p[0],p[2]);
|
||||
double ang1=getang(dis1,dis2,dis3);
|
||||
double ang2=getang(dis2,dis3,dis1);
|
||||
double ang3=getang(dis1,dis3,dis2);
|
||||
for(int i=3; i<=1000; i++)
|
||||
{
|
||||
if(ang1*i/pi-(int)(ang1*i/pi+eps)<eps && ang2*i/pi-(int)(ang2*i/pi+eps)<eps && ang3*i/pi-(int)(ang3*i/pi+eps)<eps)
|
||||
{
|
||||
printf("%d\n",i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#define N 10000000
|
||||
#define MOD 1000000007
|
||||
#define LL long long
|
||||
using namespace std;
|
||||
bool flag[N+5]={0};
|
||||
int prime[1000000],cnt=0;
|
||||
void Prime(){
|
||||
for(int i=2;i<sqrt(N+1.0);i++){
|
||||
if(flag[i])
|
||||
continue;
|
||||
for(int j=2;j*i<=N;j++)
|
||||
flag[i*j]=true;
|
||||
}
|
||||
for(int i=2;i<=N;i++)
|
||||
if(!flag[i])
|
||||
prime[cnt++]=i;
|
||||
}
|
||||
int getsum(int n,int p){
|
||||
int sum=0;
|
||||
while(n){
|
||||
sum+=n/p;
|
||||
n/=p;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
LL PowMod(LL a, LL b){
|
||||
LL ans=1;
|
||||
while(b){
|
||||
if(b&1)
|
||||
ans=(ans*a)%MOD;
|
||||
a=(a*a)%MOD;
|
||||
b>>=1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
LL fac[N+5];
|
||||
int a;
|
||||
int main(){
|
||||
int n;
|
||||
fac[1]=1;
|
||||
for(int i=2;i<=N;i++)
|
||||
fac[i]=(fac[i-1]*i)%MOD;
|
||||
Prime();
|
||||
while(scanf("%d",&n)!=EOF&&n){
|
||||
LL ret=1;
|
||||
for(int i=0;i<cnt&&prime[i]<=n;i++){
|
||||
a=getsum(n,prime[i]);
|
||||
if(a&1)
|
||||
ret=(ret*prime[i])%MOD;
|
||||
}
|
||||
printf("%I64d\n",(fac[n]*PowMod(ret,MOD-2))%MOD);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 1001;
|
||||
const double PI = acos(-1),
|
||||
EPS = 1e-8;
|
||||
struct Angle
|
||||
{
|
||||
double l,r;
|
||||
};
|
||||
bool cmp(const Angle &a,const Angle &b)
|
||||
{
|
||||
return a.l < b.l;
|
||||
}
|
||||
int n;
|
||||
Angle A[N];
|
||||
int ok(double l,double r,double x)
|
||||
{
|
||||
if(l - r < EPS)
|
||||
return l - x < EPS && x - r < EPS;
|
||||
return l - x < EPS || x - r < EPS ;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,t;
|
||||
double a,b,r;
|
||||
double x,y;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
scanf("%lf%lf%lf",&a,&b,&r);
|
||||
double dis = sqrt(a * a + b * b);
|
||||
double si = asin(r/dis);
|
||||
double ta = atan2(b,a);
|
||||
A[i].l = ta - si;
|
||||
if(A[i].l < -PI)
|
||||
A[i].l += 2 * PI;
|
||||
A[i].r = ta + si;
|
||||
if(A[i].r > PI)
|
||||
A[i].r -= 2 * PI;
|
||||
}
|
||||
sort(A, A + n, cmp);
|
||||
int res = n,tem;
|
||||
for(i = 0; i < n;++i)
|
||||
{
|
||||
tem = 1;
|
||||
double L = A[i].l,R = A[i].r;
|
||||
for(int j = 1;j < n; ++j)
|
||||
{
|
||||
int k = (i + j) % n;
|
||||
if(!ok(L,R,A[k].l))
|
||||
{
|
||||
L = A[k].l;
|
||||
R = A[k].r;
|
||||
++ tem ;
|
||||
}
|
||||
else if(ok(L,R,A[k].r))
|
||||
{
|
||||
R = A[k].r;
|
||||
}
|
||||
}
|
||||
if(tem < res)
|
||||
res = tem;
|
||||
}
|
||||
printf("%d\n",res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
int n,m,d;
|
||||
int t[4][2]={0,1,0,-1,1,0,-1,0},vist[510][510];
|
||||
int mx,my;
|
||||
char s[510][510];
|
||||
struct ss
|
||||
{
|
||||
friend bool operator<(const ss a,const ss b)
|
||||
{
|
||||
return a.sum>b.sum;
|
||||
}
|
||||
int x,y,sum;
|
||||
};
|
||||
priority_queue<ss>Q;
|
||||
void bfs()
|
||||
{
|
||||
memset(vist,0,sizeof(vist));
|
||||
ss node1,node2;
|
||||
node1.x=mx;
|
||||
node1.y=my;
|
||||
node1.sum=0;
|
||||
while(!Q.empty())
|
||||
Q.pop();
|
||||
Q.push(node1);
|
||||
vist[mx][my]=1;
|
||||
while(!Q.empty())
|
||||
{
|
||||
node1=Q.top();
|
||||
Q.pop();
|
||||
if(node1.x==0||node1.y==0||node1.x==n-1||node1.y==m-1)
|
||||
{
|
||||
printf("%d\n",node1.sum+1);
|
||||
return ;
|
||||
}
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
int xx=node1.x+t[i][0];
|
||||
int yy=node1.y+t[i][1];
|
||||
if(xx>=0&&xx<n&&yy>=0&&yy<m&&s[xx][yy]!='#'&&!vist[xx][yy])
|
||||
{
|
||||
vist[xx][yy]=1;
|
||||
node2.x=xx;
|
||||
node2.y=yy;
|
||||
if(s[xx][yy]=='.')
|
||||
node2.sum=node1.sum+1;
|
||||
else
|
||||
node2.sum=node1.sum+d+1;
|
||||
Q.push(node2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&d);
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
getchar();
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%c",&s[i][j]);
|
||||
if(s[i][j]=='S')
|
||||
{
|
||||
mx=i;
|
||||
my=j;
|
||||
s[i][j]='.';
|
||||
}
|
||||
}
|
||||
}
|
||||
bfs();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue