KiritoTRw
GitHub
parent
7a5dfb949b
commit
da5da8ec9f
|
|
@ -0,0 +1,68 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<vector>
|
||||
#include<iomanip>
|
||||
using namespace std;
|
||||
vector<double> adj[26][26];
|
||||
int deg[26];
|
||||
int main() {
|
||||
int n;
|
||||
while (cin >> n, n) {
|
||||
char v, w; double r;
|
||||
for (int i = 0; i < 26; i++) {
|
||||
for (int j = 0; j < 26; j++) {
|
||||
adj[i][j].clear();
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < n; i++) {
|
||||
cin >> v >> w >> r;
|
||||
adj[v-'A'][w-'A'].push_back(r);
|
||||
adj[w-'A'][v-'A'].push_back(r);
|
||||
}
|
||||
for (int k = 0; k < n; k++) {
|
||||
for (int i = 0; i < 26; i++) {
|
||||
for (int j = 0; j < 26; j++) {
|
||||
if (adj[i][j].size() > 1) {
|
||||
double inv_sum = 0;
|
||||
for (int s = 0; s < adj[i][j].size(); s++) {
|
||||
inv_sum += 1.0/adj[i][j][s];
|
||||
}
|
||||
adj[i][j].clear(); adj[j][i].clear();
|
||||
adj[i][j].push_back(1.0/inv_sum); adj[j][i].push_back(1.0/inv_sum);
|
||||
}
|
||||
}
|
||||
}
|
||||
memset(deg, 0, sizeof deg);
|
||||
for (int i = 0; i < 26; i++) {
|
||||
for (int j = 0; j < 26; j++) {
|
||||
if (adj[i][j].size()) deg[i]++;
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 26; i++) {
|
||||
for (int j = 0; j < 26; j++) {
|
||||
for (int l = 0; l < 26; l++) {
|
||||
if (i == l || i == j || j == l) continue;
|
||||
if (j == 0 || j == 25) continue;
|
||||
if (adj[i][j].size() && adj[j][l].size()) {
|
||||
if (deg[j] != 2) break;
|
||||
double r = adj[i][j][0] + adj[j][l][0];
|
||||
adj[i][j].clear(); adj[j][i].clear();
|
||||
adj[j][l].clear(); adj[l][j].clear();
|
||||
adj[i][l].push_back(r); adj[l][i].push_back(r);
|
||||
deg[j] = 0; deg[i]++; deg[l]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool reduced = true;
|
||||
for (int i = 1; i < 25; i++) {
|
||||
if (deg[i] != 0) reduced = false;
|
||||
}
|
||||
double ans = 0;
|
||||
if (!reduced || adj[0][25].empty()) ans = -1;
|
||||
else ans = adj[0][25][0];
|
||||
cout << fixed << setprecision(3) << ans << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <sstream>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <time.h>;
|
||||
#define cler(arr, val) memset(arr, val, sizeof(arr))
|
||||
#define FOR(i,a,b) for(int i=a;i<=b;i++)
|
||||
typedef long long LL;
|
||||
const int MAXN = 1032;
|
||||
const int MAXM = 444;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int mod = 1000000007;
|
||||
vector<int>G[MAXN];
|
||||
int val[MAXN],vis[MAXN],ans,num,orz[MAXN],man;
|
||||
void init()
|
||||
{
|
||||
for(int i=0; i<MAXN; i++)
|
||||
G[i].clear();
|
||||
cler(val,0);
|
||||
cler(vis,0);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,k;
|
||||
while(scanf("%d%d",&n,&k),n+k)
|
||||
{
|
||||
init();
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
int a,m;
|
||||
scanf("%d%d",&val[i],&m);
|
||||
for(int j=0; j<m; j++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
G[i].push_back(a);
|
||||
}
|
||||
}
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
orz[i]=val[i];
|
||||
for(int j=0; j<G[i].size(); j++)
|
||||
orz[i]+=val[G[i][j]];
|
||||
}
|
||||
ans=0,num=0;
|
||||
queue<int>q;
|
||||
for(int i=0; i<n; i++)
|
||||
if(orz[i]<k)
|
||||
q.push(i),vis[i]=1;
|
||||
while(!q.empty())
|
||||
{
|
||||
int i=q.front();
|
||||
q.pop();
|
||||
for(int j=0; j<G[i].size(); j++)
|
||||
{
|
||||
orz[G[i][j]]-=val[i];
|
||||
if(orz[G[i][j]]<k&&!vis[G[i][j]])
|
||||
q.push(G[i][j]),vis[G[i][j]]=1;
|
||||
}
|
||||
}
|
||||
for(int i=0; i<n; i++)
|
||||
if(!vis[i])
|
||||
num++,ans+=val[i];
|
||||
printf("%d %d\n",num,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define Min(a,b) a<b?a:b;
|
||||
int s[1005],ss[1005],ans[1005][1005],dp[1005];
|
||||
int main(){
|
||||
int n,m,i,j,k;
|
||||
while(~scanf("%d%d",&n,&m),(n+m)){
|
||||
memset(dp,0,sizeof(dp));
|
||||
memset(ans,0,sizeof(ans));
|
||||
ss[0]=0;
|
||||
for(i=0;i<n;i++){
|
||||
scanf("%d",&s[i]);
|
||||
ss[i+1]=ss[i]+s[i];
|
||||
}
|
||||
for(i=0;i<n;i++){
|
||||
for(j=i+1;j<n;j++)
|
||||
ans[i][j]=ans[i][j-1]+s[j]*(ss[j]-ss[i]);
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
dp[i]=ans[0][i];
|
||||
for(i=0;i<m;i++){
|
||||
for(j=n-1;j>=0;j--){
|
||||
for(k=i-1;k<j;k++)
|
||||
dp[j]=Min(dp[j],dp[k]+ans[k+1][j]);
|
||||
}
|
||||
}
|
||||
printf("%d\n",dp[n-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-5;
|
||||
const double PI = acos(-1.0);
|
||||
struct point
|
||||
{
|
||||
double x, y;
|
||||
};
|
||||
struct gao
|
||||
{
|
||||
double mz,zc;
|
||||
};
|
||||
struct gao gg[10];
|
||||
bool cmp(gao a,gao b)
|
||||
{
|
||||
if(a.mz!=b.mz)
|
||||
return a.mz>b.mz;
|
||||
return a.zc>b.zc;
|
||||
}
|
||||
double xmult(double x1,double y1,double x2,double y2,double x0,double y0)
|
||||
{
|
||||
return (x1-x0)*(y2-y0)-(x2-x0)*(y1-y0);
|
||||
}
|
||||
int same_side(point p1,point p2,point l1,point l2)
|
||||
{
|
||||
return xmult(l1.x,l1.y,p1.x,p1.y,l2.x,l2.y)*xmult(l1.x,l1.y,p2.x,p2.y,l2.x,l2.y)>0;
|
||||
}
|
||||
double dis(point a,point b)
|
||||
{
|
||||
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
point intersection(point u1,point u2,point v1,point v2)
|
||||
{
|
||||
point ret=u1;
|
||||
double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))
|
||||
/((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
|
||||
ret.x+=(u2.x-u1.x)*t;
|
||||
ret.y+=(u2.y-u1.y)*t;
|
||||
return ret;
|
||||
}
|
||||
double aera(point a,point b,point c)
|
||||
{
|
||||
double aa,bb,cc,q;
|
||||
aa=dis(c,b);
|
||||
bb=dis(a,c);
|
||||
cc=dis(b,a);
|
||||
q=(aa+bb+cc)/2;
|
||||
double h=sqrt(q*(q-aa)*(q-bb)*(q-cc));
|
||||
h=(int)(h*1000+0.5);
|
||||
return h*0.001;
|
||||
}
|
||||
double get_zc(point a,point b,point c)
|
||||
{
|
||||
double aa,bb,cc,q;
|
||||
aa=dis(c,b);
|
||||
bb=dis(a,c);
|
||||
cc=dis(b,a);
|
||||
q=(aa+bb+cc);
|
||||
return q;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
double x1,y1,x2,y2,x3,y3,x4,y4;
|
||||
point a,b,c,d,e;
|
||||
while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4)!=EOF)
|
||||
{
|
||||
if(x1==0 && y1==0 && x2==0 && y2==0 && x3==0 && y3==0 && x4==0 && y4==0)
|
||||
break;
|
||||
a.x=x1;
|
||||
a.y=y1;
|
||||
b.x=x2;
|
||||
b.y=y2;
|
||||
c.x=x3;
|
||||
c.y=y3;
|
||||
d.x=x4;
|
||||
d.y=y4;
|
||||
if(same_side(a, b, c,d)==0)
|
||||
e = intersection(d,c,a,b);
|
||||
else if(same_side(d, b, c, a)==0)
|
||||
e = intersection(d,b,c,a);
|
||||
else
|
||||
e = intersection(b,c,d,a);
|
||||
gg[0].mz=aera(a,b,e);
|
||||
gg[1].mz=aera(b,c,e);
|
||||
gg[2].mz=aera(c,d,e);
|
||||
gg[3].mz=aera(a,d,e);
|
||||
gg[0].zc=get_zc(a,b,e);
|
||||
gg[1].zc=get_zc(b,c,e);
|
||||
gg[2].zc=get_zc(c,d,e);
|
||||
gg[3].zc=get_zc(a,d,e);
|
||||
sort(gg,gg+4,cmp);
|
||||
for(i=0; i<3; i++)
|
||||
printf("%.3lf %.3lf ",gg[i].mz,gg[i].zc);
|
||||
printf("%.3lf %.3lf\n",gg[i].mz,gg[i].zc);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include<cstdio>
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int a1,a2,a3;
|
||||
int ans;
|
||||
while(~scanf("%d%d%d%d",&n,&a1,&a2,&a3))
|
||||
{
|
||||
if(n==0 && a1==0 && a2==0 && a3==0)
|
||||
break;
|
||||
ans = 4*n-1;
|
||||
if(a2>a1)
|
||||
{
|
||||
ans+=a2-a1;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans+=n+a2-a1;
|
||||
}
|
||||
if(a3<a2)
|
||||
{
|
||||
ans+=a2-a3;
|
||||
}
|
||||
else
|
||||
ans+=n+a2-a3;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
#include <stdio.h>
|
||||
int main(){
|
||||
int n,i,a;
|
||||
int f[50];
|
||||
while(scanf("%d",&n),n){
|
||||
for(i=0;i<50;i++)
|
||||
f[i]=0;
|
||||
for(i=0;i<n*6;i++){
|
||||
scanf("%d",&a);
|
||||
f[a]=1;
|
||||
}
|
||||
for(i=1;i<50;i++)
|
||||
if(f[i]==0)i=60;
|
||||
printf("%s\n",i>55?"No":"Yes");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
char a[1000];
|
||||
char einput[1000]="JOKER";
|
||||
int gnum(char x){
|
||||
if(x == 'K') return 10;
|
||||
if(x == 'Q') return 10;
|
||||
if(x == 'J') return 10;
|
||||
if(x == 'T') return 10;
|
||||
if(x == 'A') return 1;
|
||||
return int(x) - 48;
|
||||
}
|
||||
int len;
|
||||
int p, d;
|
||||
int tp, td;
|
||||
int sum;
|
||||
bool flagp, flagd;
|
||||
bool ans;
|
||||
int getp(int s, int t, bool flag){
|
||||
int result = p;
|
||||
for(int i = s; i <= t; i++){
|
||||
if(a[i] == 'A')
|
||||
flag = true;
|
||||
result += gnum(a[i]);
|
||||
}
|
||||
if(result <= 11 && flag)
|
||||
result += 10;
|
||||
return result;
|
||||
}
|
||||
int getd(int s, int t, bool flag){
|
||||
int result = d;
|
||||
if(result >= 17)
|
||||
return result;
|
||||
if(flag && result <= 11 && result + 10 >= 17)
|
||||
return result + 10;
|
||||
for(int i = s; i <= t; i++)
|
||||
if(result < 17){
|
||||
if(a[i] == 'A')
|
||||
flag = true;
|
||||
result += gnum(a[i]);
|
||||
if(flag && result <= 11 &result + 10 >= 17)
|
||||
return result + 10;
|
||||
}
|
||||
else
|
||||
return result;
|
||||
return result;
|
||||
}
|
||||
int main(){
|
||||
while(1){
|
||||
memset(a, 0, sizeof(a));
|
||||
fgets(a, 1000, stdin);
|
||||
flagp = false;
|
||||
flagd = false;
|
||||
ans = false;
|
||||
if(a[strlen(a) - 1] == '\n')
|
||||
a[strlen(a) - 1] = '\0';
|
||||
len = strlen(a);
|
||||
if(strcmp(a, einput) == 0)
|
||||
break;
|
||||
p = gnum(a[0]) + gnum(a[2]);
|
||||
d = gnum(a[1]) + gnum(a[3]);
|
||||
if(a[0] == 'A')
|
||||
flagp = true;
|
||||
if(a[2] == 'A')
|
||||
flagp = true;
|
||||
if(a[1] == 'A')
|
||||
flagd = true;
|
||||
if(a[3] == 'A')
|
||||
flagd = true;
|
||||
if(len == 4){
|
||||
if(flagp && p <= 11)
|
||||
p += 10;
|
||||
if(flagd && d <= 11)
|
||||
d += 10;
|
||||
if(p>=d)
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
else{
|
||||
sum = p;
|
||||
ans = false;
|
||||
tp = p;
|
||||
if(flagp && tp <= 11)
|
||||
tp += 10;
|
||||
td = getd(4, len-1, flagd);
|
||||
if(tp <= 21)
|
||||
if(tp >= td || td > 21)
|
||||
{
|
||||
ans = true;
|
||||
}
|
||||
for(int i = 4; i <= len - 1; i++){
|
||||
if(ans)
|
||||
break;
|
||||
sum += gnum(a[i]);
|
||||
if(sum > 21)
|
||||
break;
|
||||
tp = getp(4, i , flagp);
|
||||
td = getd(i + 1, len -1, flagd);
|
||||
if(tp <= 21)
|
||||
if(tp >= td || td > 21){
|
||||
ans = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ans)
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<ctime>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#include<map>
|
||||
using namespace std;
|
||||
vector<int> Org[30][30];
|
||||
char Trs[90][5];
|
||||
char st[60];
|
||||
int f[60][60][30];
|
||||
int Max2(int a,int b)
|
||||
{
|
||||
return a>b?a:b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int N,i,j,k,t,L,Ans;
|
||||
for (;;)
|
||||
{
|
||||
scanf("%d",&N);
|
||||
if (N==0) break;
|
||||
for (i=0;i<='T'-'A';i++)
|
||||
for (j=0;j<='T'-'A';j++)
|
||||
Org[i][j].clear();
|
||||
for (i=0;i<N;i++)
|
||||
{
|
||||
scanf("%s",Trs[i]);
|
||||
Org[Trs[i][1]-'A'][Trs[i][2]-'A'].push_back(Trs[i][0]-'A');
|
||||
}
|
||||
scanf("%s",st);
|
||||
L=strlen(st);
|
||||
memset(f,-1,sizeof(f));
|
||||
f[0][0][st[0]-'A']=0;
|
||||
for (i=1;i<L;i++)
|
||||
{
|
||||
f[i][i][st[i]-'A']=0;
|
||||
if (Org[st[i-1]-'A'][st[i]-'A'].size()!=0)
|
||||
{
|
||||
for (j=0;j<Org[st[i-1]-'A'][st[i]-'A'].size();j++)
|
||||
f[i-1][i][Org[st[i-1]-'A'][st[i]-'A'][j]]=1;
|
||||
}
|
||||
}
|
||||
for (j=2;j<L;j++)
|
||||
for (i=0;i+j<L;i++)
|
||||
{
|
||||
for (t=0;t<N;t++)
|
||||
{
|
||||
for (k=i;k<i+j;k++)
|
||||
if (f[i][k][Trs[t][1]-'A']!=-1 && f[k+1][i+j][Trs[t][2]-'A']!=-1 && (f[i][i+j][Trs[t][0]-'A']==-1 || f[i][i+j][Trs[t][0]-'A']>Max2(f[k+1][i+j][Trs[t][2]-'A'],f[i][k][Trs[t][1]-'A'])+1))
|
||||
f[i][i+j][Trs[t][0]-'A']=Max2(f[k+1][i+j][Trs[t][2]-'A'],f[i][k][Trs[t][1]-'A'])+1;
|
||||
}
|
||||
}
|
||||
Ans=-1;
|
||||
for (i=0;i<='T'-'A';i++)
|
||||
if (Ans==-1 || (f[0][L-1][i]!=-1 && Ans>f[0][L-1][i]))
|
||||
Ans=f[0][L-1][i];
|
||||
printf("%d\n",Ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int dp[1010][1010], price[1010],need[1010];
|
||||
int main()
|
||||
{
|
||||
int week,basecost,cell,storecost,i,j,k,min,mini;
|
||||
while(cin>>week)
|
||||
{
|
||||
if(week==0)
|
||||
break;
|
||||
cin>>basecost>>storecost>>cell;
|
||||
for(i=1;i<=week;i++)
|
||||
cin>>price[i]>>need[i];
|
||||
for(j=0;j<=cell;j++)
|
||||
{
|
||||
dp[1][j]=(j+need[1])*price[1]+basecost+j*storecost;
|
||||
if(need[1]==0)
|
||||
dp[1][0]=0;
|
||||
}
|
||||
for(i=2;i<=week;i++)
|
||||
for(j=0;j<=cell;j++)
|
||||
{
|
||||
min=10000000;
|
||||
for(k=0;k<=cell;k++)
|
||||
{
|
||||
if(k<=j+need[i])
|
||||
{
|
||||
if(j==k-need[i])
|
||||
mini=dp[i-1][k]+j*storecost;
|
||||
else mini=dp[i-1][k]+basecost+(j-k+need[i])*price[i]+j*storecost;
|
||||
if(mini<min)
|
||||
min=mini;
|
||||
}
|
||||
}
|
||||
dp[i][j]=min;
|
||||
}
|
||||
min=dp[week][0];
|
||||
for(i=1;i<=cell;i++)
|
||||
if(dp[week][i]<min)
|
||||
min=dp[week][i];
|
||||
cout<<min<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int INF = 0x7fffffff;
|
||||
const int NN = 350;
|
||||
const int MM = 750;
|
||||
int n,m;
|
||||
int cntc[NN];
|
||||
int L[NN*MM],R[NN*MM],U[NN*MM],D[NN*MM];
|
||||
int C[NN*MM];
|
||||
int head;
|
||||
int mx[MM][NN];
|
||||
int O[MM],idx;
|
||||
int ans[10][10];
|
||||
void remove(int c)
|
||||
{
|
||||
int i,j;
|
||||
L[R[c]] = L[c];
|
||||
R[L[c]] = R[c];
|
||||
for(i = D[c]; i != c; i = D[i])
|
||||
{
|
||||
for(j = R[i]; j != i; j = R[j])
|
||||
{
|
||||
U[D[j]] = U[j];
|
||||
D[U[j]] = D[j];
|
||||
cntc[C[j]]--;
|
||||
}
|
||||
}
|
||||
}
|
||||
void resume(int c)
|
||||
{
|
||||
int i,j;
|
||||
R[L[c]] = c;
|
||||
L[R[c]] = c;
|
||||
for(i = D[c]; i != c; i = D[i])
|
||||
{
|
||||
for(j = R[i]; j != i; j = R[j])
|
||||
{
|
||||
U[D[j]] = j;
|
||||
D[U[j]] = j;
|
||||
cntc[C[j]]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
bool dfs()
|
||||
{
|
||||
int i,j,c;
|
||||
if(R[head] == head)
|
||||
return true;
|
||||
int min = INF;
|
||||
for(i = R[head]; i != head; i = R[i])
|
||||
{
|
||||
if(cntc[i] < min)
|
||||
{
|
||||
min = cntc[i];
|
||||
c = i;
|
||||
}
|
||||
}
|
||||
remove(c);
|
||||
for(i = D[c]; i != c; i = D[i])
|
||||
{
|
||||
O[idx++] = (i-1)/n;
|
||||
for(j = R[i]; j != i; j = R[j])
|
||||
remove(C[j]);
|
||||
if(dfs())
|
||||
return true;
|
||||
for(j = L[i]; j != i; j = L[j])
|
||||
resume(C[j]);
|
||||
idx--;
|
||||
}
|
||||
resume(c);
|
||||
return false;
|
||||
}
|
||||
bool build()
|
||||
{
|
||||
int i,j,now,pre,first;
|
||||
idx = head = 0;
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
R[i] = i+1;
|
||||
L[i+1] = i;
|
||||
}
|
||||
R[n] = 0;
|
||||
L[0] = n;
|
||||
for(j = 1; j <= n; j++)
|
||||
{
|
||||
pre = j;
|
||||
cntc[j] = 0;
|
||||
for(i = 1; i <= m; i++)
|
||||
{
|
||||
if(mx[i][j])
|
||||
{
|
||||
cntc[j]++;
|
||||
now = i*n+j;
|
||||
C[now] = j;
|
||||
D[pre] = now;
|
||||
U[now] = pre;
|
||||
pre = now;
|
||||
}
|
||||
}
|
||||
U[j] = pre;
|
||||
D[pre] = j;
|
||||
if(cntc[j] == 0)
|
||||
return false;
|
||||
}
|
||||
for(i = 1; i <= m; i++)
|
||||
{
|
||||
pre = first = -1;
|
||||
for(j = 1; j <= n; j++)
|
||||
{
|
||||
if(mx[i][j])
|
||||
{
|
||||
now = i*n+j;
|
||||
if(pre == -1)
|
||||
first = now;
|
||||
else
|
||||
{
|
||||
R[pre] = now;
|
||||
L[now] = pre;
|
||||
}
|
||||
pre = now;
|
||||
}
|
||||
}
|
||||
if(first != -1)
|
||||
{
|
||||
R[pre] = first;
|
||||
L[first] = pre;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int T;
|
||||
void print()
|
||||
{
|
||||
int i,j;
|
||||
int x,y,k;
|
||||
for(i = 0; i < idx; i++)
|
||||
{
|
||||
int r = O[i];
|
||||
k = r%9;
|
||||
if(k==0) k = 9;
|
||||
int num = (r - k)/9 + 1;
|
||||
y = num%9;
|
||||
if(y == 0) y = 9;
|
||||
x = (num-y)/9 + 1;
|
||||
ans[x][y] = k;
|
||||
}
|
||||
if(idx == 0)
|
||||
printf("impossible\n");
|
||||
else
|
||||
{
|
||||
for(i = 1; i <= 9; i++)
|
||||
{
|
||||
for(j = 1; j <= 9; j++)
|
||||
printf("%d",ans[i][j]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
if(T!=0)
|
||||
printf("---\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
int cases;
|
||||
char cao[12];
|
||||
char s[12][12];
|
||||
scanf("%d",&cases);
|
||||
T = cases;
|
||||
while(T--)
|
||||
{
|
||||
if(T < cases-1)
|
||||
scanf("%s",cao);
|
||||
for(i = 1; i <= 9; i++)
|
||||
scanf("%s",&s[i][1]);
|
||||
memset(mx,0,sizeof(mx));
|
||||
for(i = 1; i <= 9; i++)
|
||||
{
|
||||
for(j = 1; j <= 9; j++)
|
||||
{
|
||||
int t = (i-1)*9 + j;
|
||||
if(s[i][j] == '?')
|
||||
{
|
||||
for(k = 1; k <= 9; k++)
|
||||
{
|
||||
mx[9*(t-1)+k][t] = 1;
|
||||
mx[9*(t-1)+k][81+(i-1)*9+k] = 1;
|
||||
mx[9*(t-1)+k][162+(j-1)*9+k] = 1;
|
||||
mx[9*(t-1)+k][243+((i-1)/3*3+(j+2)/3-1)*9+k] = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
k = s[i][j] - '0';
|
||||
mx[9*(t-1)+k][t] = 1;
|
||||
mx[9*(t-1)+k][81+(i-1)*9+k] = 1;
|
||||
mx[9*(t-1)+k][162+(j-1)*9+k] = 1;
|
||||
mx[9*(t-1)+k][243+((i-1)/3*3+(j+2)/3-1)*9+k] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
n = 324;
|
||||
m = 729;
|
||||
build();
|
||||
dfs();
|
||||
print();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const int N = 1000005;
|
||||
const int INF = 1 << 30;
|
||||
const int M = 1005;
|
||||
bool prime[N];
|
||||
int p[N];
|
||||
int pri[M],num[M];
|
||||
int arr[M];
|
||||
int k,cnt,ct;
|
||||
void isprime()
|
||||
{
|
||||
k = 0;
|
||||
memset(prime,true,sizeof(prime));
|
||||
for(int i=2;i<N;i++)
|
||||
{
|
||||
if(prime[i])
|
||||
{
|
||||
p[k++] = i;
|
||||
for(int j=i+i;j<N;j+=i)
|
||||
prime[j] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
void Divide(int n)
|
||||
{
|
||||
cnt = 0;
|
||||
int t = (int)sqrt(1.0*n);
|
||||
for(int i=0;p[i]<=t;i++)
|
||||
{
|
||||
if(n%p[i]==0)
|
||||
{
|
||||
int a = 0;
|
||||
pri[cnt] = p[i];
|
||||
while(n%p[i]==0)
|
||||
{
|
||||
n /= p[i];
|
||||
a++;
|
||||
}
|
||||
num[cnt] = a;
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
if(n > 1)
|
||||
{
|
||||
pri[cnt] = n;
|
||||
num[cnt] = 1;
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
void dfs(int dept,int product = 1)
|
||||
{
|
||||
if(dept == cnt)
|
||||
{
|
||||
arr[ct++] = product;
|
||||
return;
|
||||
}
|
||||
for(int i=0;i<=num[dept];i++)
|
||||
{
|
||||
dfs(dept+1,product);
|
||||
product *= pri[dept];
|
||||
}
|
||||
}
|
||||
void Work(int n)
|
||||
{
|
||||
ct = 0;
|
||||
Divide(n);
|
||||
dfs(0,1);
|
||||
sort(arr,arr+ct);
|
||||
int ctt = 0;
|
||||
int ansx = INF;
|
||||
int ansy = INF;
|
||||
int tmpx = 0;
|
||||
int tmpy = 0;
|
||||
for(int i=0;i<ct;i++)
|
||||
{
|
||||
int t = n / arr[i] * 12 - 3 * arr[i] * arr[i];
|
||||
if(t >= 0)
|
||||
{
|
||||
int tmp = (int)sqrt(t * 1.0);
|
||||
if(tmp * tmp == t)
|
||||
{
|
||||
if((3*arr[i] - tmp)%6==0)
|
||||
{
|
||||
ctt++;
|
||||
tmpx = (3*arr[i] - tmp) / 6;
|
||||
if(tmpx < ansx)
|
||||
{
|
||||
ansx = tmpx;
|
||||
ansy = arr[i] - tmpx;
|
||||
}
|
||||
}
|
||||
if((3*arr[i] + tmp)%6==0)
|
||||
{
|
||||
ctt++;
|
||||
tmpx = (3*arr[i] + tmp) / 6;
|
||||
if(tmpx < ansx)
|
||||
{
|
||||
ansx = tmpx;
|
||||
ansy = arr[i] - tmpx;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ctt == 0) puts("Impossible");
|
||||
else printf("%d %d\n",ansx,ansy);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
isprime();
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
if(n == 0) break;
|
||||
Work(n);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <iostream>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int MAX = 16000;
|
||||
int mod = 10000;
|
||||
int fiblast[MAX] = {0, 1, 1}, fib[MAX] = {0, 1, 1};
|
||||
double N1 = (1.0 + sqrt(5.0)) / 2.0;
|
||||
void pre_init()
|
||||
{
|
||||
for(int i = 3; i < MAX; i++)
|
||||
{
|
||||
fiblast[i] = (fiblast[i - 1] + fiblast[i - 2]) % mod;
|
||||
if(fiblast[i] == fiblast[1] && fiblast[i - 1] == fiblast[0])
|
||||
break;
|
||||
fib[i] = fib[i - 1] + fib[i - 2];
|
||||
}
|
||||
return ;
|
||||
}
|
||||
int main(void)
|
||||
{
|
||||
pre_init();
|
||||
int n;
|
||||
while(scanf("%d", &n) == 1)
|
||||
{
|
||||
if(n < 40)
|
||||
{
|
||||
printf("%d\n", fib[n]);
|
||||
continue;
|
||||
}
|
||||
double k = log10(1.0/sqrt(5.0)) + (double)n * log10(N1);
|
||||
double tmp = k;
|
||||
tmp = k - (int)tmp;
|
||||
printf("%d...%0.4d\n", (int)(1000.0 * pow(10.0, tmp)), fiblast[n % 15000]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define INF 1000000000
|
||||
int tou[305],wei[305];
|
||||
int ji1[20],ji2[20];
|
||||
int poww(int a,int b)
|
||||
{
|
||||
int sum=1;
|
||||
for(int i=0;i<b;i++)
|
||||
{
|
||||
sum*=a;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,n,m;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d%d",&tou[i],&wei[i]);
|
||||
}
|
||||
int min=INF,sum;
|
||||
int k=poww(2,n-1);
|
||||
for(int i=0;i<=k;i++)
|
||||
{
|
||||
int k=i;
|
||||
int count=0;
|
||||
sum=0;
|
||||
memset(ji1,0,sizeof(ji1));
|
||||
while(k)
|
||||
{
|
||||
ji1[count++]=k%2;
|
||||
k/=2;
|
||||
}
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
if(ji1[tou[j]]==ji1[wei[j]]) sum++;
|
||||
if(sum>min) break;
|
||||
}
|
||||
if(sum<min) min=sum;
|
||||
}
|
||||
printf("%d\n",min);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#define PI 3.14159265358979323846
|
||||
#define eps 1e-8
|
||||
using namespace std;
|
||||
inline int SGN(double x){return x < -eps ? -1 : x < eps ? 0 : 1;}
|
||||
inline double SQR(double x){return x * x;}
|
||||
struct pt
|
||||
{
|
||||
double x, y;
|
||||
pt(){}
|
||||
pt(double _x, double _y):x(_x), y(_y){}
|
||||
pt operator - (const pt p1){return pt(x - p1.x, y - p1.y);}
|
||||
pt operator + (const pt p1){return pt(x + p1.x, y + p1.y);}
|
||||
pt operator * (double r){return pt(x * r, y * r);}
|
||||
pt operator / (double r){return pt(x / r, y / r);}
|
||||
void read(){scanf("%lf %lf", &x, &y);}
|
||||
};
|
||||
inline double cpr(const pt &a,const pt &b){return a.x*b.y-a.y*b.x;}
|
||||
inline double dis(const pt &a, const pt &b){return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
|
||||
inline double dis2(const pt &a, const pt &b){return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);}
|
||||
inline void intersection_circle_circle(pt &c1, double r1, pt &c2, double r2, pt &p1, pt &p2)
|
||||
{
|
||||
double d2 = (c1.x - c2.x) * (c1.x - c2.x) + (c1.y - c2.y) * (c1.y - c2.y);
|
||||
double cos = (r1 * r1 + d2 - r2 * r2) / (2 * r1 * sqrt(d2));
|
||||
pt v1 = (c2 - c1) / dis(c1, c2), v2 = pt(-v1.y, v1.x) * (r1 * sqrt(1 - cos * cos));
|
||||
pt X = c1 + v1 * (r1 * cos);
|
||||
p1 = X + v2;
|
||||
p2 = X - v2;
|
||||
}
|
||||
struct Event
|
||||
{
|
||||
double pos;
|
||||
int del;
|
||||
pt X;
|
||||
bool operator < (const Event e)const{return pos < e.pos;}
|
||||
};
|
||||
int n;
|
||||
pt o[400];
|
||||
double r[400];
|
||||
Event e[800];
|
||||
int cnt;
|
||||
double ans[10];
|
||||
int sc[400];
|
||||
inline int rlt(int a, int b)
|
||||
{
|
||||
double d = dis2(o[a], o[b]), df = SGN(d - SQR(r[a] - r[b]));
|
||||
if (df <= 0)return !SGN(r[a] - r[b]) ? a < b : r[a] < r[b];
|
||||
return d < SQR(r[a] + r[b]) - eps ? 2 : 3;
|
||||
}
|
||||
inline double arcArea(double r, Event e1, Event e2)
|
||||
{
|
||||
double dif = e2.pos - e1.pos;
|
||||
return (cpr(e1.X, e2.X) + (dif - sin(dif)) * r * r) * 0.5;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
double center, d2, ang, angX, angY;
|
||||
pt X, Y, L;
|
||||
Event last;
|
||||
memset(ans, 0, sizeof(ans));
|
||||
for (int i = 0; i < n; i++) if (r[i] > eps)
|
||||
{
|
||||
int acc[4] = {0};
|
||||
cnt = 0;
|
||||
L = pt(o[i].x - r[i], o[i].y);
|
||||
e[cnt].pos = -PI, e[cnt].del = sc[i], e[cnt++].X = L;
|
||||
e[cnt].pos = PI, e[cnt].del = -sc[i], e[cnt++].X = L;
|
||||
for (int j = 0; j < n; j++) if (i != j && r[j] > eps)
|
||||
{
|
||||
int rel = rlt(i, j);
|
||||
if (rel == 1)
|
||||
{
|
||||
e[cnt].pos = -PI, e[cnt].del = sc[j], e[cnt++].X = L;
|
||||
e[cnt].pos = PI, e[cnt].del = -sc[j], e[cnt++].X = L;
|
||||
} else if (rel == 2)
|
||||
{
|
||||
intersection_circle_circle(o[i], r[i], o[j], r[j], X, Y);
|
||||
angX = atan2(X.y - o[i].y, X.x - o[i].x);
|
||||
angY = atan2(Y.y - o[i].y, Y.x - o[i].x);
|
||||
if (angX < angY) acc[sc[j]]++;
|
||||
e[cnt].pos = angY, e[cnt].del = sc[j], e[cnt++].X = Y;
|
||||
e[cnt].pos = angX, e[cnt].del = -sc[j], e[cnt++].X = X;
|
||||
}
|
||||
}
|
||||
sort(e, e + cnt);
|
||||
last.pos = -PI, last.X = pt(o[i].x - r[i], o[i].y);
|
||||
for (int j = 0; j < cnt; j++)
|
||||
{
|
||||
double tmp = arcArea(r[i], last, e[j]);
|
||||
ans[!!acc[1] + 2 * !!acc[2] + 4 * !!acc[3]] += tmp;
|
||||
ans[!!(acc[1] - (sc[i] == 1)) + 2 * !!(acc[2] - (sc[i] == 2)) + 4 * !!(acc[3] - (sc[i] == 3))] -= tmp;
|
||||
acc[abs(e[j].del)] += SGN(e[j].del);
|
||||
last = e[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
void fun()
|
||||
{
|
||||
int n1, n2, n3;
|
||||
scanf("%d %d %d", &n1, &n2, &n3);
|
||||
n = n1 + n2 + n3;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
o[i].read();
|
||||
scanf("%lf", &r[i]);
|
||||
sc[i] = i < n1 ? 1 : i < n1 + n2 ? 2 : 3;
|
||||
}
|
||||
solve();
|
||||
printf("%.2f %.2f %.2f %.2f %.2f %.2f %.2f\n", fabs(ans[1]), fabs(ans[2]), fabs(ans[4]), fabs(ans[7]), fabs(ans[3]), fabs(ans[5]), fabs(ans[6]));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int tc;
|
||||
scanf ("%d", &tc);
|
||||
while (tc--)fun();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#include<map>
|
||||
#include<ctime>
|
||||
using namespace std;
|
||||
const int MAX=1005;
|
||||
const int inf=1<<26;
|
||||
struct node
|
||||
{
|
||||
int v,w,next;
|
||||
}g[MAX*100];
|
||||
int adj[MAX],e,vis1[MAX],vis2[MAX],kind[MAX],n,m;
|
||||
int dis[MAX],fa[MAX],pre[MAX];
|
||||
int flag[MAX];
|
||||
bool pos[MAX],found;
|
||||
void add(int u,int v,int w)
|
||||
{
|
||||
g[e].v=v; g[e].w=w; g[e].next=adj[u]; adj[u]=e++;
|
||||
}
|
||||
void spfa(int s,int t,int k)
|
||||
{
|
||||
int i,u,v;
|
||||
queue<int>que;
|
||||
for(i=0;i<=n;i++)
|
||||
dis[i]=inf;
|
||||
if(k)
|
||||
memset(pre,-1,sizeof(pre));
|
||||
dis[s]=0;
|
||||
memset(vis1,0,sizeof(vis1));
|
||||
vis1[s]=1;
|
||||
que.push(s);
|
||||
while(!que.empty())
|
||||
{
|
||||
u=que.front();
|
||||
que.pop();
|
||||
vis1[u]=0;
|
||||
for(i=adj[u];i!=-1;i=g[i].next)
|
||||
{
|
||||
v=g[i].v;
|
||||
if(vis2[kind[v]])
|
||||
continue;
|
||||
if(dis[v]>dis[u]+g[i].w)
|
||||
{
|
||||
dis[v]=dis[u]+g[i].w;
|
||||
pre[v]=u;
|
||||
if(!vis1[v])
|
||||
{
|
||||
vis1[v]=1;
|
||||
que.push(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool check()
|
||||
{
|
||||
for(int i=0;i<MAX;i++)
|
||||
if(flag[i]>1)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
bool dfs(int u,int now,int limit,int t)
|
||||
{
|
||||
if(now>limit)
|
||||
return false;
|
||||
if(u==t)
|
||||
return true;
|
||||
spfa(u,t,0);
|
||||
if(now+dis[t]>limit)
|
||||
return false;
|
||||
int i,v;
|
||||
for(i=adj[u];i!=-1;i=g[i].next)
|
||||
{
|
||||
v=g[i].v;
|
||||
if(vis2[kind[v]])
|
||||
continue;
|
||||
vis2[kind[v]]=1;
|
||||
if(dfs(v,now+g[i].w,limit,t))
|
||||
return true;
|
||||
vis2[kind[v]]=0;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void solve(int s,int t,int sum)
|
||||
{
|
||||
int l=1,r=sum,ans=-1,mid;
|
||||
while(l<=r)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
memset(vis2,0,sizeof(vis2));
|
||||
vis2[kind[s]]=1;
|
||||
if(dfs(s,0,mid,t))
|
||||
{
|
||||
ans=mid;
|
||||
r=mid-1;
|
||||
}
|
||||
else
|
||||
l=mid+1;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
inline int nextInt()
|
||||
{
|
||||
int res = 0; char ch;
|
||||
bool neg = false;
|
||||
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-');
|
||||
if (ch == '-') neg = true;
|
||||
else res = ch - '0';
|
||||
while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - '0';
|
||||
if (neg) res = - res;
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,T,s,t,sum=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d%d",&n,&m,&s,&t);
|
||||
memset(adj,-1,sizeof(adj));
|
||||
e=0;
|
||||
while(m--)
|
||||
{
|
||||
i=nextInt(); j=nextInt(); k=nextInt();
|
||||
add(i,j,k); add(j,i,k);
|
||||
sum+=k;
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
kind[i]=nextInt();
|
||||
}
|
||||
if(s==t)
|
||||
{
|
||||
puts("0");
|
||||
continue;
|
||||
}
|
||||
memset(vis2,0,sizeof(vis2));
|
||||
vis2[kind[t]]=1;
|
||||
spfa(t,s,1);
|
||||
memset(flag,0,sizeof(flag));
|
||||
if(pre[s]==-1)
|
||||
{
|
||||
puts("-1");
|
||||
continue;
|
||||
}
|
||||
for(i=s;i!=-1;i=pre[i])
|
||||
{
|
||||
flag[kind[i]]++;
|
||||
}
|
||||
if(check())
|
||||
{
|
||||
printf("%d\n",dis[s]);
|
||||
continue;
|
||||
}
|
||||
solve(s,t,sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define MIN(x,y) (x<y?x:y)
|
||||
int g,b,p;
|
||||
int G,B,P;
|
||||
int gdeg[22];
|
||||
int grank[22];
|
||||
int gb[22],gp[22],bp[22];
|
||||
bool in(){
|
||||
char c=getchar();
|
||||
while(c<=32) c=getchar();
|
||||
return (c=='1');
|
||||
}
|
||||
int vis;
|
||||
int mat[22];
|
||||
inline bool find0(int u){
|
||||
for(int i=0;i<b;i++){
|
||||
if(B&(1<<i)) continue;
|
||||
if(!(gb[u]&(1<<i))) continue;
|
||||
if(vis&(1<<i)) continue;
|
||||
vis|=(1<<i);
|
||||
if(mat[i]==-1||find0(mat[i])){
|
||||
mat[i]=u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
inline bool find1(int u){
|
||||
for(int i=0;i<p;i++){
|
||||
if(P&(1<<i)) continue;
|
||||
if(!(gp[u]&(1<<i))) continue;
|
||||
if(vis&(1<<i)) continue;
|
||||
vis|=(1<<i);
|
||||
if(mat[i]==-1||find1(mat[i])){
|
||||
mat[i]=u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
inline bool find2(int u){
|
||||
for(int i=0;i<p;i++){
|
||||
if(P&(1<<i)) continue;
|
||||
if(!(bp[u]&(1<<i))) continue;
|
||||
if(vis&(1<<i)) continue;
|
||||
vis|=(1<<i);
|
||||
if(mat[i]==-1||find2(mat[i])){
|
||||
mat[i]=u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int dep;
|
||||
inline bool h(int d,int tg){
|
||||
int cnt=0;
|
||||
memset(mat,-1,sizeof(mat));
|
||||
for(int i=tg;i<g;i++){
|
||||
vis=0;
|
||||
if(find0(grank[i])) cnt++;
|
||||
if(cnt>dep-d) break;
|
||||
}
|
||||
if(cnt+d<dep) return false;
|
||||
cnt=0;
|
||||
memset(mat,-1,sizeof(mat));
|
||||
for(int i=tg;i<g;i++){
|
||||
vis=0;
|
||||
if(find1(grank[i])) cnt++;
|
||||
if(cnt>dep-d) break;
|
||||
}
|
||||
if(cnt+d<dep) return false;
|
||||
cnt=0;
|
||||
memset(mat,-1,sizeof(mat));
|
||||
for(int i=0;i<b;i++){
|
||||
if(B&(1<<i)) continue;
|
||||
vis=0;
|
||||
if(find2(i)) cnt++;
|
||||
if(cnt>dep-d) break;
|
||||
}
|
||||
if(cnt+d<dep) return false;
|
||||
return true;
|
||||
}
|
||||
bool dfs(int d,int tg){
|
||||
if(d==dep) return true;
|
||||
if(!h(d,tg)) return false;
|
||||
for(int ii=tg;ii<g;ii++){
|
||||
int i=grank[ii];
|
||||
G|=(1<<i);
|
||||
for(int j=0;j<b;j++){
|
||||
if(B&(1<<j)) continue;
|
||||
if(!(gb[i]&(1<<j))) continue;
|
||||
B|=(1<<j);
|
||||
for(int k=0;k<p;k++){
|
||||
if(P&(1<<k)) continue;
|
||||
if(gp[i]&bp[j]&(1<<k)){
|
||||
P|=(1<<k);
|
||||
if(dfs(d+1,ii+1)) return true;
|
||||
P^=(1<<k);
|
||||
}
|
||||
}
|
||||
B^=(1<<j);
|
||||
}
|
||||
G^=(1<<i);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool gcmp(const int& a,const int& b){
|
||||
return gdeg[a]<gdeg[b];
|
||||
}
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d%d%d",&g,&b,&p);
|
||||
memset(gb,0,sizeof(gb));
|
||||
memset(gp,0,sizeof(gp));
|
||||
memset(bp,0,sizeof(bp));
|
||||
memset(gdeg,0,sizeof(gdeg));
|
||||
for(int i=0;i<g;i++){
|
||||
for(int j=0;j<b;j++){
|
||||
gb[i]|=(in()<<j);
|
||||
}
|
||||
}
|
||||
for(int i=0;i<g;i++){
|
||||
for(int j=0;j<p;j++){
|
||||
gp[i]|=(in()<<j);
|
||||
}
|
||||
}
|
||||
for(int i=0;i<b;i++){
|
||||
for(int j=0;j<p;j++){
|
||||
bp[i]|=(in()<<j);
|
||||
}
|
||||
}
|
||||
for(int i=0;i<g;i++){
|
||||
grank[i]=i;
|
||||
for(int j=0;j<b;j++){
|
||||
if(!(gp[i]&bp[j])) gb[i]&=~(1<<j);
|
||||
if(gb[i]&(1<<j)) gdeg[i]++;
|
||||
}
|
||||
}
|
||||
sort(grank,grank+g,gcmp);
|
||||
G=B=P=0;
|
||||
dep=MIN(MIN(g,b),p);
|
||||
while(true){
|
||||
if(dfs(0,0)) break;
|
||||
dep--;
|
||||
}
|
||||
printf("%d\n",dep);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
char s[200000];
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
__int64 n,m,i,j,ans,carry;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%s %I64d",s,&m);
|
||||
n=0;
|
||||
for(i=0;s[i];i++)
|
||||
{
|
||||
n=n*10+s[i]-'0';
|
||||
if(n>=m)
|
||||
{
|
||||
n=m-1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
ans=1;
|
||||
carry=1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
carry=(carry*i)%m;
|
||||
ans=(ans+carry)%m;
|
||||
}
|
||||
printf("%I64d\n",ans%m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define left Left
|
||||
#define right Right
|
||||
#define eps 1e-8
|
||||
#define maxn 60000
|
||||
double x[maxn],y[maxn],r[maxn];
|
||||
int left[maxn],right[maxn],up[maxn],rank_up[maxn];
|
||||
int n;
|
||||
set<int> my_set;
|
||||
double mid;
|
||||
bool cmp_left(const int &a,const int &b)
|
||||
{
|
||||
return x[a]-r[a] < x[b]-r[b];
|
||||
}
|
||||
bool cmp_right(const int &a,const int &b)
|
||||
{
|
||||
return x[a]+r[a] < x[b]+r[b];
|
||||
}
|
||||
bool cmp_up(const int &a,const int &b)
|
||||
{
|
||||
if(y[a]==y[b])
|
||||
return x[a] < x[b];
|
||||
else return y[a] < y[b];
|
||||
}
|
||||
double my_sqr(double a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
bool is_cross(int a,int b)
|
||||
{
|
||||
a=up[a],b=up[b];
|
||||
double t1,t2;
|
||||
t1=my_sqr(x[a]-x[b])+my_sqr(y[a]-y[b]),t2=my_sqr(r[a]+r[b]+mid+mid);
|
||||
if(t1<=t2)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
bool insert(int a)
|
||||
{
|
||||
set<int>::iterator it=my_set.insert(a).first;
|
||||
if(it!=my_set.begin())
|
||||
{
|
||||
if(is_cross(a,*--it))
|
||||
return true;
|
||||
it++;
|
||||
}
|
||||
if(++it!=my_set.end())
|
||||
{
|
||||
if(is_cross(a,*it))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool is_ok()
|
||||
{
|
||||
my_set.clear();
|
||||
int i=0,j=0;
|
||||
while(i<n || j<n)
|
||||
{
|
||||
if(j==n ||(i!=n && x[left[i]]-r[left[i]]-mid<x[right[j]]+r[right[j]]+mid))
|
||||
{
|
||||
if(insert(rank_up[left[i++]]))
|
||||
return true;
|
||||
}
|
||||
else
|
||||
my_set.erase(rank_up[right[j++]]);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
double find_ans()
|
||||
{
|
||||
double l=0,ri=sqrt(my_sqr(x[0]-x[1])+my_sqr(y[0]-y[1]))-r[0]-r[1];
|
||||
while(l+eps<ri)
|
||||
{
|
||||
mid=(l+ri)/2;
|
||||
if(is_ok())
|
||||
ri=mid;
|
||||
else
|
||||
l=mid;
|
||||
}
|
||||
printf("%.6lf\n",l+ri);
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,j,k;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%lf%lf%lf",&x[i],&y[i],&r[i]);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
left[i]=i;
|
||||
right[i]=i;
|
||||
up[i]=i;
|
||||
}
|
||||
sort(left,left+n,cmp_left);
|
||||
sort(right,right+n,cmp_right);
|
||||
sort(up,up+n,cmp_up);
|
||||
for(i=0;i<n;i++)
|
||||
rank_up[up[i]]=i;
|
||||
find_ans();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
int Check(char s[])
|
||||
{
|
||||
int i,len;
|
||||
len=strlen(s);
|
||||
if(s[0]=='\\'||s[0]=='/')
|
||||
{
|
||||
return (1);
|
||||
}
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(s[i]=='\\')
|
||||
{
|
||||
s[i]='/';
|
||||
}
|
||||
}
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(s[i]==':')
|
||||
{
|
||||
if(s[i+1]=='/'&&s[i+2]=='/')
|
||||
{
|
||||
return (2);
|
||||
}
|
||||
else if(s[i+1]=='/'&&s[i+2]!='/')
|
||||
{
|
||||
return (3);
|
||||
}
|
||||
}
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
char str[64];
|
||||
while(scanf("%d",&t)!=EOF)
|
||||
{
|
||||
getchar();
|
||||
while(t--)
|
||||
{
|
||||
int i,tag;
|
||||
memset(str,0,sizeof(str));
|
||||
gets(str);
|
||||
tag=Check(str);
|
||||
if(tag==1||tag==2)
|
||||
{
|
||||
printf("%s\n",tag==1?"It's a path in Unix-like systems!":"It's a URL!");
|
||||
for(i=0;str[i]!='\0';i++)
|
||||
{
|
||||
if(str[i]=='\\')
|
||||
{
|
||||
str[i]='/';
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(tag==3)
|
||||
{
|
||||
printf("It's a path in Windows system!\n");
|
||||
for(i=0;str[i]!='\0';i++)
|
||||
{
|
||||
if(str[i]=='/')
|
||||
{
|
||||
str[i]='\\';
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%s\n",str);
|
||||
}
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
|
@ -0,0 +1,200 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef double db;
|
||||
const db eps=1e-7;
|
||||
const int MAXN=1005;
|
||||
const int MAXM=100005;
|
||||
const int INF=0x3f3f3f3f;
|
||||
struct Edge
|
||||
{
|
||||
int to,next,cap,flow;
|
||||
}edge[MAXM];
|
||||
int tol,head[MAXN];
|
||||
int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN];
|
||||
void init()
|
||||
{
|
||||
tol=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
}
|
||||
void addedge(int u,int v,int w,int rw=0)
|
||||
{
|
||||
edge[tol].to=v;
|
||||
edge[tol].cap=w;
|
||||
edge[tol].next=head[u];
|
||||
edge[tol].flow=0;
|
||||
head[u]=tol++;
|
||||
edge[tol].to=u;
|
||||
edge[tol].cap=rw;
|
||||
edge[tol].next=head[v];
|
||||
edge[tol].flow=0;
|
||||
head[v]=tol++;
|
||||
}
|
||||
int sap(int st,int ed,int N)
|
||||
{
|
||||
memset(gap,0,sizeof(gap));
|
||||
memset(dep,0,sizeof(dep));
|
||||
memcpy(cur,head,sizeof(head));
|
||||
int u=st;
|
||||
pre[u]=-1;
|
||||
gap[0]=N;
|
||||
int ans=0;
|
||||
while(dep[st]<N)
|
||||
{
|
||||
if(u==ed)
|
||||
{
|
||||
int Min=INF;
|
||||
for(int i=pre[u];i!=-1;i=pre[edge[i^1].to])
|
||||
if(Min>edge[i].cap-edge[i].flow)
|
||||
Min=edge[i].cap-edge[i].flow;
|
||||
for(int i=pre[u];i!=-1;i=pre[edge[i^1].to])
|
||||
{
|
||||
edge[i].flow+=Min;
|
||||
edge[i^1].flow-=Min;
|
||||
}
|
||||
u=st;
|
||||
ans+=Min;
|
||||
continue;
|
||||
}
|
||||
bool flag=0;
|
||||
int v;
|
||||
for(int i=cur[u];i!=-1;i=edge[i].next)
|
||||
{
|
||||
v=edge[i].to;
|
||||
if(edge[i].cap-edge[i].flow && dep[v]+1==dep[u])
|
||||
{
|
||||
flag=1;
|
||||
cur[u]=pre[v]=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
u=v;
|
||||
continue;
|
||||
}
|
||||
int Min=N;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next)
|
||||
if(edge[i].cap-edge[i].flow && dep[edge[i].to]<Min)
|
||||
{
|
||||
Min=dep[edge[i].to];
|
||||
cur[u]=i;
|
||||
}
|
||||
gap[dep[u]]--;
|
||||
if(!gap[dep[u]])return ans;
|
||||
dep[u]=Min+1;
|
||||
gap[dep[u]]++;
|
||||
if(u!=st)u=edge[pre[u]^1].to;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
struct Point
|
||||
{
|
||||
db x,y;
|
||||
Point(){}
|
||||
Point(db _x,db _y):x(_x),y(_y){}
|
||||
Point operator + (const Point &t)const
|
||||
{
|
||||
return Point(x+t.x,y+t.y);
|
||||
}
|
||||
Point operator - (const Point &t)const
|
||||
{
|
||||
return Point(x-t.x,y-t.y);
|
||||
}
|
||||
Point operator * (const db &t)const
|
||||
{
|
||||
return Point(x*t,y*t);
|
||||
}
|
||||
db operator * (const Point &t)const
|
||||
{
|
||||
return x*t.x+y*t.y;
|
||||
}
|
||||
db operator ^ (const Point &t)const
|
||||
{
|
||||
return x*t.y-y*t.x;
|
||||
}
|
||||
db len()
|
||||
{
|
||||
return sqrt(x*x+y*y);
|
||||
}
|
||||
}p[205];
|
||||
struct Line
|
||||
{
|
||||
Point s,e;
|
||||
Line(){}
|
||||
Line(Point _s,Point _e):s(_s),e(_e){}
|
||||
};
|
||||
Point PTS(Point P,Line L)
|
||||
{
|
||||
Point result;
|
||||
db t=((P-L.s)*(L.e-L.s))/((L.e-L.s)*(L.e-L.s));
|
||||
if(t>=0 && t<=1)
|
||||
{
|
||||
result=L.s+(L.e-L.s)*t;
|
||||
}
|
||||
else
|
||||
{
|
||||
if((P-L.s).len()<(P-L.e).len())result=L.s;
|
||||
else result=L.e;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
struct Circle
|
||||
{
|
||||
Point o;
|
||||
db r;
|
||||
Circle(){}
|
||||
Circle(Point _o,db _r):o(_o),r(_r){}
|
||||
}c[205],tr[205];
|
||||
int v[205];
|
||||
vector<pair<int,int> >e;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int n,m,k;
|
||||
scanf("%d%d%d",&n,&m,&k);
|
||||
int Max=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%lf%lf%lf%d",&c[i].o.x,&c[i].o.y,&c[i].r,&v[i]);
|
||||
for(int i=1;i<=m;i++)
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
for(int i=1;i<=k;i++)
|
||||
scanf("%lf%lf%lf",&tr[i].o.x,&tr[i].o.y,&tr[i].r);
|
||||
for(int i=1;i<=n;i++)
|
||||
Max=max(Max,v[i]);
|
||||
e.clear();
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=1;j<=m;j++)
|
||||
if((c[i].o-p[j]).len()<c[i].r+eps)
|
||||
{
|
||||
bool isok=1;
|
||||
for(int t=1;t<=k;t++)
|
||||
if((PTS(tr[t].o,Line(c[i].o,p[j]))-tr[t].o).len()<tr[t].r+eps)
|
||||
isok=0;
|
||||
if(isok)
|
||||
e.push_back(make_pair(i,n+j));
|
||||
}
|
||||
int l=0,r=(m-1)*Max+2;
|
||||
while(l<r)
|
||||
{
|
||||
int tt=(l+r)>>1;
|
||||
init();
|
||||
for(int i=1;i<=n;i++)
|
||||
addedge(0,i,tt/v[i]+1);
|
||||
for(int i=0;i<(int)e.size();i++)
|
||||
addedge(e[i].first,e[i].second,1);
|
||||
for(int i=1;i<=m;i++)
|
||||
addedge(n+i,n+m+1,1);
|
||||
if(sap(0,n+m+1,n+m+2)<m)l=tt+1;
|
||||
else r=tt;
|
||||
}
|
||||
printf("%d\n",(l==(m-1)*Max+2 ? -1 : l));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int x,y,v;
|
||||
}a[20];
|
||||
int dp[1005][1005];
|
||||
int main()
|
||||
{
|
||||
int i,j,k,n,X,Y,t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&X,&Y);
|
||||
for(i = 0;i<n;i++)
|
||||
scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].v);
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(i = 0;i<=X;i++)
|
||||
{
|
||||
for(j = 0;j<=Y;j++)
|
||||
{
|
||||
for(k = 0;k<n;k++)
|
||||
{
|
||||
if(i>=a[k].x && j>=a[k].y)
|
||||
dp[i][j] = max(dp[i][j],max((dp[i-a[k].x][j]+dp[a[k].x][j-a[k].y]),(dp[i][j-a[k].y]+dp[i-a[k].x][a[k].y]))+a[k].v);
|
||||
if(i>=a[k].y && j>=a[k].x)
|
||||
dp[i][j] = max(dp[i][j],max((dp[i-a[k].y][j]+dp[a[k].y][j-a[k].x]),(dp[i][j-a[k].x]+dp[i-a[k].y][a[k].x]))+a[k].v);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",dp[X][Y]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
int main()
|
||||
{
|
||||
double n, m;
|
||||
char s[17];
|
||||
double time;
|
||||
while(~scanf("%lf%lf",&n,&m))
|
||||
{
|
||||
double sum1 = 0;
|
||||
double sum2 = 0;
|
||||
double v1 = 0;
|
||||
double v2 = 0;
|
||||
for(int i = 0; i < 20; i++)
|
||||
{
|
||||
scanf("%s%lf",s,&time);
|
||||
if(s[0]=='A' || s[0]=='a')
|
||||
{
|
||||
sum1 += time;
|
||||
v1 += n/time;
|
||||
}
|
||||
else
|
||||
{
|
||||
sum2 += time;
|
||||
v2 += m/time;
|
||||
}
|
||||
}
|
||||
printf("Method 1\n");
|
||||
printf("African: %.2lf furlongs per hour\n",n*10.0/sum1);
|
||||
printf("European: %.2lf furlongs per hour\n",m*10.0/sum2);
|
||||
printf("Method 2\n");
|
||||
printf("African: %.2lf furlongs per hour\n",v1/10.0);
|
||||
printf("European: %.2lf furlongs per hour\n",v2/10.0);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
char s[1017];
|
||||
int tt = 0;
|
||||
while(gets(s))
|
||||
{
|
||||
tt++;
|
||||
int len = strlen(s);
|
||||
for(int i = 0; i < len; i++)
|
||||
{
|
||||
if(i == 0 && tt > 1)
|
||||
{
|
||||
while(s[i]==' ' || s[i]=='(' || s[i]==')')
|
||||
{
|
||||
i++;
|
||||
if(i >= len)
|
||||
break;
|
||||
}
|
||||
s[i] = toupper(s[i]);
|
||||
}
|
||||
else if(s[i]=='.' || s[i]=='!' || s[i]=='?')
|
||||
{
|
||||
i++;
|
||||
while(s[i]==' ' || s[i]=='(' || s[i]==')')
|
||||
{
|
||||
i++;
|
||||
if(i >= len)
|
||||
break;
|
||||
}
|
||||
s[i] = toupper(s[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
s[i] = tolower(s[i]);
|
||||
}
|
||||
}
|
||||
printf("%s\n",s);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
int main()
|
||||
{
|
||||
for(int i = 100; i <= 999; i++)
|
||||
{
|
||||
for(int j = 100; j <= 999; j++)
|
||||
{
|
||||
int t1 = (i-i%10)/10;
|
||||
int t2 = j-j/100*100;
|
||||
int x1 = i%10;
|
||||
int x2 = j/100;
|
||||
if(x1==x2 && i/(j*1.0)==t1/(t2*1.0) && i != j)
|
||||
{
|
||||
printf("%d / %d = %d / %d\n",i,j,t1,t2);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include <stdio.h>
|
||||
#include <map>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#define LL __int64
|
||||
using namespace std;
|
||||
LL a[20],cnt,k;
|
||||
map<LL,LL> ans;
|
||||
map<LL,LL>::iterator it;
|
||||
bool cmp(LL a,LL b)
|
||||
{
|
||||
return a>b;
|
||||
}
|
||||
LL cal(LL sum,LL temp,LL op)
|
||||
{
|
||||
if(op==0)
|
||||
return sum+temp;
|
||||
if(op==1)
|
||||
return sum-temp>0? sum-temp:temp-sum;
|
||||
if(op==2)
|
||||
return sum*temp;
|
||||
if(op==3)
|
||||
return sum/temp;
|
||||
}
|
||||
void dfs(LL x,LL sum)
|
||||
{
|
||||
if(x==cnt)
|
||||
{
|
||||
LL tempsum=sum;
|
||||
while(tempsum)
|
||||
{
|
||||
if(tempsum%10==3)
|
||||
{
|
||||
ans[sum]++;
|
||||
k++;
|
||||
break;
|
||||
}
|
||||
tempsum/=10;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
for(LL i=0;i<4;i++)
|
||||
{
|
||||
if(i==3 && a[x]==0)
|
||||
continue;
|
||||
LL temp=cal(sum,a[x],i);
|
||||
dfs(x+1,temp);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char s[100];
|
||||
LL len,i;
|
||||
while(gets(s))
|
||||
{
|
||||
if(s[0]=='#')
|
||||
break;
|
||||
ans.clear();
|
||||
len=strlen(s);
|
||||
LL temp;
|
||||
cnt=temp=0;
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(s[i]==' ')
|
||||
{
|
||||
a[cnt++]=temp;
|
||||
temp=0;
|
||||
continue;
|
||||
}
|
||||
temp=temp*10+s[i]-'0';
|
||||
}
|
||||
a[cnt++]=temp;
|
||||
k=0;
|
||||
dfs(1,a[0]);
|
||||
if(k)
|
||||
{
|
||||
LL maxt=-1,maxans;
|
||||
for(it=ans.begin();it!=ans.end();it++)
|
||||
{
|
||||
if(maxt<=(it->second))
|
||||
{
|
||||
maxt=it->second;
|
||||
maxans=it->first;
|
||||
if((it->first)>maxans)
|
||||
maxans=it->first;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",maxans);
|
||||
}
|
||||
else
|
||||
printf("No result\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
0.00 to 365.25: 2099.8021
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
const double EPS = 1e-3;
|
||||
const double PAI = 4 * atan(1.0);
|
||||
const float FLOAT_MAX = 1.0e38, FLOAT_MIN = -1.0e38;
|
||||
const double DOUBLE_MAX = 1.79e308, DOUBLE_MIN = -1.79e308;
|
||||
const int N = 3005;
|
||||
struct node{
|
||||
int x, y, z, id;
|
||||
};
|
||||
node a[N];
|
||||
int f[N];
|
||||
int n, l;
|
||||
void add(int x, int y, int z, int id){
|
||||
a[l].x = x;
|
||||
a[l].y = y;
|
||||
a[l].z = z;
|
||||
a[l].id = id;
|
||||
l++;
|
||||
}
|
||||
void input(){
|
||||
int i, x, y, z;
|
||||
l = 0;
|
||||
add(-1,-1, -1, 0);
|
||||
for(i = 1; i <= n; i++){
|
||||
scanf("%d x %d x %d", &x, &y, &z);
|
||||
add(x,y,z,i);
|
||||
add(x,z,y,i);
|
||||
add(y,x,z,i);
|
||||
add(y,z,x,i);
|
||||
add(z,x,y,i);
|
||||
add(z,y,x,i);
|
||||
}
|
||||
}
|
||||
bool cmp(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.z < b.z;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i,j, res;
|
||||
sort(a, a+1, cmp);
|
||||
res = 0;
|
||||
f[0] = 0;
|
||||
for(i = 1; i < l; i++)
|
||||
{
|
||||
f[i] = 1;
|
||||
for(j = 1; j < i; j++)
|
||||
if(a[i].id != a[j].id && a[j].x < a[i].x && a[j].y < a[i].y && a[j].z < a[i].z)
|
||||
f[i] = max(f[i],f[j]+1);
|
||||
res = max(res, f[i]);
|
||||
}
|
||||
printf("%d\n", res);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d", &n) && n != -1){
|
||||
input();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
XXXXXXXXXXXXXX
|
||||
X XXX
|
||||
X XFXXXXX X
|
||||
XXX XX XX X
|
||||
X S X
|
||||
XX XXXXXX X X
|
||||
X X X X
|
||||
X X X X X
|
||||
XXX XX X
|
||||
XXXXXXXXXXXXXX
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <sstream>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#include <map>
|
||||
#define cler(arr, val) memset(arr, val, sizeof(arr))
|
||||
typedef long long LL;
|
||||
const int MAXN = 543;
|
||||
const int MAXM = 260110;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int mod = 1000000007;
|
||||
struct Edge
|
||||
{
|
||||
int to,next,cap,flow;
|
||||
}edge[MAXM];
|
||||
int tol;
|
||||
int head[MAXN];
|
||||
int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN];
|
||||
void init()
|
||||
{
|
||||
tol = 0;
|
||||
memset(head,-1,sizeof (head));
|
||||
}
|
||||
void addedge (int u,int v,int w,int rw=0)
|
||||
{
|
||||
edge[tol].to = v;edge[tol].cap = w;edge[tol].next = head[u];
|
||||
edge[tol].flow = 0;head[u] = tol++;
|
||||
edge[tol].to = u;edge[tol].cap = rw;edge[tol]. next = head[v];
|
||||
edge[tol].flow = 0;head[v]=tol++;
|
||||
}
|
||||
int sap(int start,int end, int N)
|
||||
{
|
||||
memset(gap,0,sizeof(gap));
|
||||
memset(dep,0,sizeof(dep));
|
||||
memcpy(cur,head,sizeof(head));
|
||||
int u = start;
|
||||
pre[u] = -1;
|
||||
gap[0] = N;
|
||||
int ans = 0;
|
||||
int i;
|
||||
while(dep[start] < N)
|
||||
{
|
||||
if(u == end)
|
||||
{
|
||||
int Min = INF;
|
||||
for( i = pre[u];i != -1; i = pre[edge[i^1]. to])
|
||||
{
|
||||
if(Min > edge[i].cap - edge[i]. flow)
|
||||
Min = edge[i].cap - edge[i].flow;
|
||||
}
|
||||
for( i = pre[u];i != -1; i = pre[edge[i^1]. to])
|
||||
{
|
||||
edge[i].flow += Min;
|
||||
edge[i^1].flow -= Min;
|
||||
}
|
||||
u = start;
|
||||
ans += Min;
|
||||
continue;
|
||||
}
|
||||
bool flag = false;
|
||||
int v;
|
||||
for( i = cur[u]; i != -1;i = edge[i].next)
|
||||
{
|
||||
v = edge[i]. to;
|
||||
if(edge[i].cap - edge[i].flow && dep[v]+1 == dep[u])
|
||||
{
|
||||
flag = true;
|
||||
cur[u] = pre[v] = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
u = v;
|
||||
continue;
|
||||
}
|
||||
int Min = N;
|
||||
for( i = head[u]; i != -1;i = edge[i]. next)
|
||||
{
|
||||
if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
|
||||
{
|
||||
Min = dep[edge[i].to];
|
||||
cur[u] = i;
|
||||
}
|
||||
}
|
||||
gap[dep[u]]--;
|
||||
if(!gap[dep[u]]) return ans;
|
||||
dep[u] = Min+1;
|
||||
gap[dep[u]]++;
|
||||
if(u != start) u = edge[pre[u]^1].to;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int n,m,s,e;
|
||||
void build()
|
||||
{
|
||||
init();
|
||||
s=n+1,e=n+2;
|
||||
int u,v,w;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&w);
|
||||
if(w==0)
|
||||
addedge(s,i,1);
|
||||
else
|
||||
addedge(i,e,1);
|
||||
}
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
addedge(u,v,1);
|
||||
addedge(v,u,1);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m),n+m)
|
||||
{
|
||||
build();
|
||||
printf("%d\n",sap(s,e,n+2));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
#include<cstdio>
|
||||
int main(){
|
||||
int a,e,f,c,b;
|
||||
while(~scanf("%d%d%d",&e,&f,&c)){
|
||||
for(a=e+f,b=0;a>=c;a=a%c+a/c)
|
||||
b+=a/c;
|
||||
printf("%d\n",b);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 100+5;
|
||||
int head[N],cnt,n,e,p,d;
|
||||
#define pc 160
|
||||
#define eps 1e-8
|
||||
#define INF 0x3f3f3f3f
|
||||
double dist1[N],dist2[N];
|
||||
bool out[N];
|
||||
struct edges
|
||||
{
|
||||
int u,cost,next;
|
||||
edges(){}
|
||||
edges(int a,int b,int c):u(a),cost(b),next(c){}
|
||||
}edge[N*N];
|
||||
void init(){
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(out,0,sizeof(out));
|
||||
cnt = 0;
|
||||
}
|
||||
void add_edge(int a,int b,int c){
|
||||
edge[cnt] = edges(b,c,head[a]);
|
||||
head[a] = cnt++;
|
||||
}
|
||||
bool inQue[N];
|
||||
queue<int>que;
|
||||
void spfa(double dist[],int src)
|
||||
{
|
||||
for(int i = 1; i <= n; ++i) dist[i] = INF,inQue[i] = 0;
|
||||
while(!que.empty()) que.pop();
|
||||
que.push(src);
|
||||
dist[src] = 0;
|
||||
inQue[src] = true;
|
||||
while(!que.empty())
|
||||
{
|
||||
int u = que.front();que.pop();
|
||||
for(int i = head[u]; i + 1 ; i =edge[i].next)
|
||||
{
|
||||
int v = edge[i].u;
|
||||
int val = edge[i].cost;
|
||||
if(src == p && v == d) continue;
|
||||
if(dist[u] + val < dist[v])
|
||||
{
|
||||
dist[v] = dist[u] + val;
|
||||
if(!inQue[v]) que.push(v),inQue[v] = true;
|
||||
}
|
||||
}
|
||||
inQue[u] = false;
|
||||
}
|
||||
}
|
||||
queue<int>qq;
|
||||
bool has[N];
|
||||
bool bfs(double vi)
|
||||
{
|
||||
while(!qq.empty()) qq.pop();
|
||||
qq.push(p);
|
||||
for(int i = 1; i <= n; ++i) has[i] = 0;
|
||||
while(!qq.empty())
|
||||
{
|
||||
int u = qq.front();
|
||||
if(out[u]) return true;
|
||||
qq.pop();
|
||||
for(int i = head[u]; i + 1; i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].u;
|
||||
if(has[v]||dist1[v]*pc>=dist2[v]*vi) continue;
|
||||
qq.push(v);
|
||||
has[v] = 1;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m;
|
||||
while(scanf("%d%d%d",&n,&m,&e)!=EOF)
|
||||
{
|
||||
init();
|
||||
for(int i = 0,x,y,z; i < m; ++i)
|
||||
{
|
||||
scanf("%d%d%d",&x,&y,&z);
|
||||
add_edge(x,y,z);
|
||||
add_edge(y,x,z);
|
||||
}
|
||||
for(int i = 0; i < e; ++i) scanf("%d",&p),out[p]=1;
|
||||
scanf("%d%d",&p,&d);
|
||||
spfa(dist1,p);
|
||||
spfa(dist2,d);
|
||||
double left = 0,right = INF,ans = -1;
|
||||
while(left+eps<right)
|
||||
{
|
||||
double mid = (right+left)/2;
|
||||
if(bfs(mid)) right= mid,ans = mid;
|
||||
else left = mid;
|
||||
}
|
||||
if(ans < 0)printf("IMPOSSIBLE\n");
|
||||
else printf("%.9f\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
using namespace std;
|
||||
map<int,int> s;
|
||||
map<int,int>::iterator it;
|
||||
double eps=1e-10;
|
||||
int n,m;
|
||||
const double pi=acos(-1.0);
|
||||
int fa[1001],x[1001],y[1001],cx[1001],cy[1001],r[1001];
|
||||
struct Eve
|
||||
{
|
||||
double ang;
|
||||
int id,L,f;
|
||||
bool operator<(const Eve &b)const
|
||||
{
|
||||
if(fabs(ang-b.ang)>eps)return ang<b.ang;
|
||||
return f>b.f;
|
||||
}
|
||||
}p[8001];
|
||||
int find(int x)
|
||||
{
|
||||
if(x==fa[x])return x;
|
||||
return fa[x]=find(fa[x]);
|
||||
}
|
||||
void U(int i,int j)
|
||||
{
|
||||
fa[find(i)]=find(j);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
for(int i=0;i<n;i++){scanf("%d%d",x+i,y+i);fa[i]=i;}
|
||||
for(int i=0;i<m;i++)scanf("%d%d%d",cx+i,cy+i,r+i);
|
||||
if(m==0){puts("0");continue;}
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int t=0;
|
||||
for(int j=i+1;j<n;j++)
|
||||
{
|
||||
p[t].ang=atan2((double)(y[j]-y[i]),(double)(x[j]-x[i]));
|
||||
if(p[t].ang<-eps)p[t].ang+=pi*2;
|
||||
p[t].id=j;
|
||||
p[t].L=(x[j]-x[i])*(x[j]-x[i])+(y[j]-y[i])*(y[j]-y[i]);
|
||||
p[t++].f=0;
|
||||
}
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
double th=atan2((double)(cy[j]-y[i]),(double)(cx[j]-x[i]));
|
||||
int d=(cx[j]-x[i])*(cx[j]-x[i])+(cy[j]-y[i])*(cy[j]-y[i]);
|
||||
double dt=asin((double)r[j]/sqrt((double)d));
|
||||
int ds=d-r[j]*r[j];
|
||||
double u=th-dt,v=th+dt;
|
||||
if(u<0)u+=pi*2,v+=pi*2;
|
||||
if(v<pi*2+eps)
|
||||
{
|
||||
p[t].L=ds;
|
||||
p[t].ang=u;
|
||||
p[t++].f=1;
|
||||
p[t].L=ds;
|
||||
p[t].ang=v;
|
||||
p[t++].f=-1;
|
||||
}
|
||||
else
|
||||
{
|
||||
p[t].L=ds;
|
||||
p[t].ang=u;
|
||||
p[t++].f=1;
|
||||
p[t].L=ds;
|
||||
p[t].ang=pi*2;
|
||||
p[t++].f=-1;
|
||||
p[t].L=ds;
|
||||
p[t].ang=0;
|
||||
p[t++].f=1;
|
||||
p[t].L=ds;
|
||||
p[t].ang=v-pi*2;
|
||||
p[t++].f=-1;
|
||||
}
|
||||
}
|
||||
sort(p,p+t);
|
||||
s.clear();
|
||||
for(int j=0,tot=0;j<t;j++)
|
||||
{
|
||||
if(p[j].f==0)
|
||||
{
|
||||
if(tot==0)U(i,p[j].id);
|
||||
else
|
||||
{
|
||||
it=s.begin();
|
||||
if(it->first>p[j].L)U(i,p[j].id);
|
||||
}
|
||||
}
|
||||
else if(p[j].f==1)
|
||||
{
|
||||
s[p[j].L]++;
|
||||
++tot;
|
||||
}
|
||||
else
|
||||
{
|
||||
s[p[j].L]--;
|
||||
if(s[p[j].L]==0)s.erase(p[j].L);
|
||||
--tot;
|
||||
}
|
||||
}
|
||||
}
|
||||
int cnt=0;
|
||||
for(int i=0;i<n;i++)if(find(i)==i)++cnt;
|
||||
printf("%d\n",--cnt);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
#define maxn 10010
|
||||
#define maxm 1000010
|
||||
#define inf 0x3f3f3f3f
|
||||
char table[11][11];
|
||||
int row[333], col[333];
|
||||
void change(char &c1, char &c2){
|
||||
if(row[c1] == row[c2])
|
||||
c1 = table[row[c1]][col[c1]+1], c2 = table[row[c2]][col[c2]+1];
|
||||
else if(col[c1] == col[c2])
|
||||
c1 = table[row[c1]+1][col[c1]], c2 = table[row[c2]+1][col[c2]];
|
||||
else{
|
||||
int r1 = row[c1], co1 = col[c1];
|
||||
int r2 = row[c2], co2 = col[c2];
|
||||
c1 = table[r1][co2], c2 = table[r2][co1];
|
||||
}
|
||||
}
|
||||
void update(char c, int &x, int &y){
|
||||
table[x][y] = c;
|
||||
row[c] = x;
|
||||
col[c] = y;
|
||||
y++;
|
||||
if(y == 6)
|
||||
x++, y = 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
char s[2222];
|
||||
while(gets(s)){
|
||||
memset(table, 0, sizeof(table));
|
||||
memset(row, 0, sizeof(row));
|
||||
memset(col, 0, sizeof(col));
|
||||
int curi = 1, curj = 1;
|
||||
int l1 = strlen(s);
|
||||
for(int i = 0; i < l1; ++i){
|
||||
if(s[i] == 'q' || s[i] <'a' || s[i] >'z')
|
||||
continue;
|
||||
if(row[s[i]] == 0){
|
||||
update(s[i],curi, curj);
|
||||
}
|
||||
}
|
||||
if(curi < 6)
|
||||
for(int i = 0; i < 26; ++i)
|
||||
if(row['a'+i] == 0 && 'a' + i != 'q')
|
||||
update('a'+i, curi, curj);
|
||||
for(int j = 1; j <= 5; ++j)
|
||||
table[6][j] = table[1][j];
|
||||
for(int i = 1; i <= 5; ++i)
|
||||
table[i][6] = table[i][1];
|
||||
char c1 = 0, c2 = 0;
|
||||
gets(s);
|
||||
int l = 0, r = strlen(s);
|
||||
while(l<r){
|
||||
if(s[l] == ' '|| s[l] == 'q'){
|
||||
l++;
|
||||
continue;
|
||||
}
|
||||
if(s[l] <'a' || s[l] >'z'){
|
||||
l++;
|
||||
continue;
|
||||
}
|
||||
if(c1 == 0){
|
||||
c1 = s[l++];
|
||||
continue;
|
||||
}
|
||||
if(c1 && c1 !=s[l])
|
||||
c2 = s[l++];
|
||||
else if(c1)
|
||||
c2 = 'x';
|
||||
change(c1, c2);
|
||||
printf("%c%c", c1-'a'+'A', c2-'a'+'A');
|
||||
c1 = c2 = 0;
|
||||
}
|
||||
if(c1){
|
||||
c2 = 'x';
|
||||
change(c1, c2);
|
||||
printf("%c%c", c1-'a'+'A', c2-'a'+'A');
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <cstdio>
|
||||
#include <map>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
map<string,int>mm;
|
||||
int main()
|
||||
{
|
||||
string name[117];
|
||||
int t;
|
||||
int n;
|
||||
int cas = 0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
mm.clear();
|
||||
for(int i = 0; i < n; i++)
|
||||
{
|
||||
cin>>name[i];
|
||||
}
|
||||
int m;
|
||||
scanf("%d",&m);
|
||||
char s[1000];
|
||||
string ss="";
|
||||
for(int i = 0; i < m; i++)
|
||||
{
|
||||
getchar();
|
||||
gets(s);
|
||||
for(int j = 0; j < strlen(s); j++)
|
||||
{
|
||||
if(s[j]==' ')
|
||||
{
|
||||
mm[ss]++;
|
||||
ss="";
|
||||
continue;
|
||||
}
|
||||
ss+=s[j];
|
||||
}
|
||||
mm[ss]++;
|
||||
ss="";
|
||||
}
|
||||
printf("Test set %d:\n",++cas);
|
||||
for(int i = 0 ; i < n; i++)
|
||||
{
|
||||
if(mm[name[i]])
|
||||
{
|
||||
cout<<name[i]<<" is present"<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<name[i]<<" is absent"<<endl;
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define INF 1000000000
|
||||
const double eps = 1e-8;
|
||||
const double pi = acos(-1.0);
|
||||
int cmp(double x)
|
||||
{
|
||||
if (fabs(x) < eps) return 0;
|
||||
if (x > 0) return 1;
|
||||
return -1;
|
||||
}
|
||||
inline double sqr(double x){return x*x;}
|
||||
struct point
|
||||
{
|
||||
double x,y;
|
||||
point(){}
|
||||
point(double a,double b):x(a),y(b){}
|
||||
void input()
|
||||
{
|
||||
scanf("%lf%lf",&x,&y);
|
||||
}
|
||||
friend point operator + (const point &a, const point &b)
|
||||
{
|
||||
return point(a.x+b.x, a.y+b.y);
|
||||
}
|
||||
friend point operator - (const point &a, const point &b)
|
||||
{
|
||||
return point(a.x-b.x, a.y-b.y);
|
||||
}
|
||||
friend bool operator == (const point &a, const point &b)
|
||||
{
|
||||
return cmp(a.x-b.x)==0 && cmp(a.y-b.y)==0;
|
||||
}
|
||||
friend point operator * (const point &a, const double &b)
|
||||
{
|
||||
return point(a.x*b, a.y*b);
|
||||
}
|
||||
friend point operator * (const double &a, const point &b)
|
||||
{
|
||||
return point(a*b.x, a*b.y);
|
||||
}
|
||||
friend point operator / (const point &a, const double &b)
|
||||
{
|
||||
return point(a.x/b, a.y/b);
|
||||
}
|
||||
bool operator<(const point& a)const
|
||||
{
|
||||
if (cmp(x-a.x)!=0) return x<a.x;
|
||||
return y<a.y;
|
||||
}
|
||||
double norm()
|
||||
{
|
||||
return sqrt(sqr(x) + sqr(y));
|
||||
}
|
||||
};
|
||||
double det(const point &a, const point &b)
|
||||
{
|
||||
return a.x*b.y-a.y*b.x;
|
||||
}
|
||||
double dot(const point &a,const point &b)
|
||||
{
|
||||
return a.x*b.x+a.y*b.y;
|
||||
}
|
||||
double dis_point_segment(point p, point s, point t)
|
||||
{
|
||||
if (cmp(dot(p-s, t-s)) < 0) return (p-s).norm();
|
||||
if (cmp(dot(p-t, s-t)) < 0) return (p-t).norm();
|
||||
return fabs(det(s-p, t-p)) / (s-t).norm();
|
||||
}
|
||||
double caldis(point a, point b, point c, point d)
|
||||
{
|
||||
if (cmp(det(a-c, d-c) * det(b-c, d-c)) < 0 &&
|
||||
cmp(det(c-a, b-a) * det(d-a, b-a)) < 0) return 0.0;
|
||||
double t1 = min(dis_point_segment(a, c, d), dis_point_segment(b, c, d));
|
||||
double t2 = min(dis_point_segment(c, a, b), dis_point_segment(d, a, b));
|
||||
return min(t1, t2);
|
||||
}
|
||||
int W, n;
|
||||
vector<point> con[110];
|
||||
double dis[110][110];
|
||||
int fa[110];
|
||||
int get_fa(int x)
|
||||
{
|
||||
if (fa[x] == x) return x;
|
||||
fa[x] = get_fa(fa[x]);
|
||||
return fa[x];
|
||||
}
|
||||
void merge(int x,int y)
|
||||
{
|
||||
x=get_fa(x);y=get_fa(y);
|
||||
fa[x] = y;
|
||||
}
|
||||
bool check(double d)
|
||||
{
|
||||
for (int i=0; i<n+2; i++) fa[i]=i;
|
||||
for (int i=0; i<n+2; i++)
|
||||
{
|
||||
for (int j=i+1; j<n+2; j++)
|
||||
if (cmp(dis[i][j] - d)<0)
|
||||
merge(i,j);
|
||||
}
|
||||
int x=get_fa(n), y=get_fa(n+1);
|
||||
if (x==y) return false;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&W,&n)!=EOF)
|
||||
{
|
||||
if (W==0 && n==0) break;
|
||||
double w = W/2.0;
|
||||
for (int i=0;i<n;i++)
|
||||
{
|
||||
int k;
|
||||
scanf("%d",&k);
|
||||
con[i].clear();
|
||||
for (int j=1; j<=k; j++)
|
||||
{
|
||||
double x,y;
|
||||
scanf("%lf%lf",&x,&y);
|
||||
con[i].push_back(point(x,y));
|
||||
}
|
||||
con[i].push_back(con[i][0]);
|
||||
for (int j=0; j<i; j++)
|
||||
{
|
||||
dis[i][j]=INF;
|
||||
for (int k=0; k+1<con[i].size(); k++)
|
||||
for (int d=0; d+1<con[j].size(); d++)
|
||||
dis[i][j]=min(dis[i][j], caldis(con[i][k],con[i][k+1], con[j][d],con[j][d+1]));
|
||||
dis[j][i] = dis[i][j];
|
||||
}
|
||||
dis[i][n] = dis[i][n+1] = INF;
|
||||
for (int j=0; j<con[i].size(); j++)
|
||||
{
|
||||
dis[i][n] = min(dis[i][n], w-con[i][j].y);
|
||||
dis[i][n+1] = min(dis[i][n+1], w+con[i][j].y);
|
||||
}
|
||||
dis[n][i] = dis[i][n];
|
||||
dis[n+1][i] = dis[i][n+1];
|
||||
}
|
||||
dis[n][n+1]=dis[n+1][n] = w * 2.0;
|
||||
double L=0.0, r=w, mid;
|
||||
for (int i=0; i<n; i++)
|
||||
for (int j=0; j+1<con[i].size(); j++)
|
||||
r = min(r, dis_point_segment(point(0,0), con[i][j], con[i][j+1]));
|
||||
r*=2.0;
|
||||
while((r-L)>eps)
|
||||
{
|
||||
mid=(L+r)/2.0;
|
||||
if (check(mid)) L=mid;
|
||||
else r=mid;
|
||||
}
|
||||
if (cmp(L)>0) printf("%.2lf\n",L/2.0);
|
||||
else printf("impossible\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<cstring>
|
||||
#define maxn 125+5
|
||||
using namespace std;
|
||||
int n;
|
||||
int casee=1;
|
||||
int mapp[maxn][maxn];
|
||||
int visit[maxn][maxn];
|
||||
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
|
||||
struct stu
|
||||
{
|
||||
int x,y;
|
||||
int sum;
|
||||
friend bool operator<(stu x,stu y)
|
||||
{
|
||||
return x.sum>y.sum;
|
||||
}
|
||||
};
|
||||
void bfs()
|
||||
{
|
||||
stu x,y;
|
||||
priority_queue<stu>root;
|
||||
x.x=0;
|
||||
x.y=0;
|
||||
x.sum=mapp[0][0];
|
||||
visit[0][0]=1;
|
||||
root.push(x);
|
||||
while(root.size())
|
||||
{
|
||||
x=root.top();
|
||||
root.pop();
|
||||
if(x.x==n-1&&x.y==n-1){cout<<"Problem "<<casee++<<": "<<x.sum<<endl;return;}
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
y.x=x.x+dir[i][0];
|
||||
y.y=x.y+dir[i][1];
|
||||
if(y.x<0||y.x>=n||y.y<0||y.y>=n||visit[y.x][y.y]){continue;}
|
||||
y.sum=x.sum+mapp[y.x][y.y];
|
||||
root.push(y);
|
||||
visit[y.x][y.y]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(cin>>n&&n)
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
cin>>mapp[i][j];
|
||||
}
|
||||
}
|
||||
memset(visit,0,sizeof(visit));
|
||||
bfs();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
Case n:
|
||||
nn pencils for nn cents
|
||||
nn at four cents each
|
||||
nn at two for a penny
|
||||
nn at four for a penny
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <stdlib.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <list>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int, char>PII;
|
||||
typedef pair<PII, int>PII2;
|
||||
PII in[20];
|
||||
int n;
|
||||
int maxSolve = 0, minnTime;
|
||||
PII order[20];
|
||||
PII ans[20];
|
||||
void search(int a, int b, int c, int at, int t)
|
||||
{
|
||||
if(a > 300) return ;
|
||||
if(b > 300) return ;
|
||||
if(c > 300) return ;
|
||||
if(at > maxSolve)
|
||||
{
|
||||
maxSolve = at;
|
||||
minnTime = t;
|
||||
for(int i = 0; i < at; i++ )
|
||||
ans[i] = order[i];
|
||||
}
|
||||
else if(at == maxSolve)
|
||||
{
|
||||
if(t < minnTime)
|
||||
{
|
||||
minnTime = t;
|
||||
for(int i = 0; i < at; i++ )
|
||||
ans[i] = order[i];
|
||||
}
|
||||
else if(t == minnTime)
|
||||
{
|
||||
sort(ans, ans + maxSolve);
|
||||
PII temp[20];
|
||||
for(int i = 0; i < maxSolve; i++ ) temp[i] = order[i];
|
||||
sort(temp, temp + maxSolve);
|
||||
int swap = 0;
|
||||
for(int i = 0; i < maxSolve; i++ )
|
||||
{
|
||||
if(temp[i].second < ans[i].second)
|
||||
{
|
||||
swap = 1;
|
||||
break;
|
||||
}
|
||||
else if(temp[i].second > ans[i].second)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(swap)
|
||||
{
|
||||
for(int i = 0; i < maxSolve; i++ ) ans[i] = temp[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
if(at == n) return ;
|
||||
order[at] = PII(a + in[at].first, in[at].second);
|
||||
search(a + in[at].first, b, c, at + 1, t + a + in[at].first);
|
||||
order[at] = PII(b + in[at].first, in[at].second);
|
||||
search(a, b + in[at].first, c, at + 1, t + b + in[at].first);
|
||||
order[at] = PII(c + in[at].first, in[at].second);
|
||||
search(a, b, c + in[at].first, at + 1, t + c + in[at].first);
|
||||
}
|
||||
class Solve
|
||||
{
|
||||
public:
|
||||
void main2()
|
||||
{
|
||||
cin >> n;
|
||||
for(int i = 0; i < n; i++ )
|
||||
{
|
||||
cin >> in[i].first;
|
||||
in[i].second = 'A' + i;
|
||||
}
|
||||
sort(in, in + n);
|
||||
maxSolve = 1;
|
||||
minnTime = in[0].first;
|
||||
order[0] = PII(in[0].first, in[0].second);
|
||||
search(in[0].first, 0, 0, 1, in[0].first);
|
||||
sort(ans, ans + maxSolve);
|
||||
for(int i = 0; i < maxSolve; i++ ) printf("%c ", ans[i].second);
|
||||
printf("%d %d\n", maxSolve, minnTime);
|
||||
}
|
||||
};
|
||||
int main()
|
||||
{
|
||||
int Test;
|
||||
scanf("%d", &Test);
|
||||
for(int t = 1; t <= Test; t++ )
|
||||
{
|
||||
Solve ___test;
|
||||
printf("Data set %d: ", t);
|
||||
___test.main2();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <stdlib.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <list>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int, int>PII;
|
||||
typedef pair<PII, int>PII2;
|
||||
string s;
|
||||
int n;
|
||||
int len;
|
||||
map<char, int>val;
|
||||
int value[20];
|
||||
int at;
|
||||
int good;
|
||||
int eva()
|
||||
{
|
||||
// cout << at << " " << s[at] << endl;
|
||||
if(good != 1) return 0;
|
||||
if(at >= len)
|
||||
{
|
||||
good = -2;
|
||||
}
|
||||
else if(s[at] >= 'a' && s[at] <= 'z')
|
||||
{
|
||||
return value[val[s[at++]]];
|
||||
}
|
||||
else if(s[at] >= 'A' && s[at] <= 'Z')
|
||||
{
|
||||
at++;
|
||||
int x, y;
|
||||
switch(s[at - 1])
|
||||
{
|
||||
case 'C': x = eva(); y = eva(); if(x && !y) return 0; else return 1;
|
||||
case 'N': x = eva(); return x ^ 1;
|
||||
case 'K': x = eva(); y = eva(); return x & y;
|
||||
case 'A': x = eva(); y = eva(); return x | y;
|
||||
case 'D': x = eva(); y = eva(); return !(x & y);
|
||||
case 'E': x = eva(); y = eva(); return (x == y);
|
||||
case 'J': x = eva(); y = eva(); return x ^ y;
|
||||
default: good = -1; break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
good = -1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(cin >> s)
|
||||
{
|
||||
good = 1;
|
||||
len = s.length();
|
||||
n = 0;
|
||||
val.clear();
|
||||
for(int i = 0; i < len; i++ )
|
||||
{
|
||||
if(s[i] >= 'a' && s[i] <= 'z' && val.find(s[i]) == val.end())
|
||||
{
|
||||
val[s[i]] = n++;
|
||||
}
|
||||
}
|
||||
int ct = 0, cn = 0;
|
||||
for(int i = 0; i < 1<<n && good == 1; i++ )
|
||||
{
|
||||
for(int j = 0; j < n; j++ )
|
||||
{
|
||||
if(i & (1<<j))
|
||||
value[j] = 1;
|
||||
else
|
||||
value[j] = 0;
|
||||
}
|
||||
at = 0;
|
||||
int res = eva();
|
||||
if(good == 1 && at < len) good = -3;
|
||||
if(res) ct++;
|
||||
else cn++;
|
||||
}
|
||||
cout << s << " is ";
|
||||
if(good == 1)
|
||||
{
|
||||
cout << "valid: ";
|
||||
if(ct && cn) cout << "contingent" << endl;
|
||||
else if(ct) cout << "tautology" << endl;
|
||||
else cout << "contradiction" << endl;
|
||||
}
|
||||
else if(good == -1)
|
||||
{
|
||||
cout << "invalid: invalid character" << endl;
|
||||
}
|
||||
else if(good == -2)
|
||||
{
|
||||
cout << "invalid: insufficient operands" << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << "invalid: extraneous text" << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,223 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<math.h>
|
||||
const int CCC=20;
|
||||
const int RR=400;
|
||||
const int V=8000;
|
||||
const double eps=1e-7;
|
||||
const int N=65550;
|
||||
bool hash[N];
|
||||
int st[N];
|
||||
const double pi = acos(-1.0);
|
||||
int U[V],D[V];
|
||||
int L[V],R[V];
|
||||
int C[V];
|
||||
int size,S[CCC],H[RR],n,m;
|
||||
int dir[17]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536};
|
||||
struct node{
|
||||
double x,y;
|
||||
}s[20];
|
||||
struct point{
|
||||
double x,y;
|
||||
}cnt,cnt1;
|
||||
double Dis(point a,point b){
|
||||
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
point Whirl(double cosl, double sinl, point a, point b)
|
||||
{
|
||||
b.x -= a.x; b.y -= a.y;
|
||||
point c;
|
||||
c.x = b.x * cosl - b.y * sinl + a.x;
|
||||
c.y = b.x * sinl + b.y * cosl + a.y;
|
||||
return c;
|
||||
}
|
||||
point inst(point u1,point u2,point v1,point v2)
|
||||
{
|
||||
point ans = u1;
|
||||
double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/
|
||||
((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x));
|
||||
ans.x += (u2.x - u1.x)*t;
|
||||
ans.y += (u2.y - u1.y)*t;
|
||||
return ans;
|
||||
}
|
||||
point fun(point a,point b,double r)
|
||||
{
|
||||
double l=Dis(a,b);
|
||||
double ans=acos((l/2)/r);
|
||||
point k1=Whirl(cos(ans),sin(ans),a,b);
|
||||
point k2=Whirl(cos(ans),-sin(ans),b,a);
|
||||
point cent=inst(a,k1,b,k2);
|
||||
return cent;
|
||||
}
|
||||
void Link(int r,int c)
|
||||
{
|
||||
S[c]++;C[size]=c;
|
||||
U[size]=U[c];D[U[c]]=size;
|
||||
D[size]=c;U[c]=size;
|
||||
if(H[r]==-1) H[r]=L[size]=R[size]=size;
|
||||
else
|
||||
{
|
||||
L[size]=L[H[r]];R[L[H[r]]]=size;
|
||||
R[size]=H[r];L[H[r]]=size;
|
||||
}
|
||||
size++;
|
||||
}
|
||||
void remove(int c)
|
||||
{
|
||||
int i;
|
||||
for(i=D[c];i!=c;i=D[i])
|
||||
L[R[i]]=L[i],R[L[i]]=R[i];
|
||||
}
|
||||
void resume(int c)
|
||||
{
|
||||
int i;
|
||||
for(i=U[c];i!=c;i=U[i])
|
||||
L[R[i]]=R[L[i]]=i;
|
||||
}
|
||||
int h()
|
||||
{
|
||||
int i,j,k,count=0;
|
||||
bool visit[20];
|
||||
memset(visit,0,sizeof(visit));
|
||||
for(i=R[0];i;i=R[i])
|
||||
{
|
||||
if(visit[i]) continue;
|
||||
count++;
|
||||
visit[i]=1;
|
||||
for(j=D[i];j!=i;j=D[j])
|
||||
{
|
||||
for(k=R[j];k!=j;k=R[k])
|
||||
visit[C[k]]=1;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
int Dance(int k)
|
||||
{
|
||||
int i,j,Min,c;
|
||||
if(k+h()>m) return 0;
|
||||
if(!R[0]) return 1;
|
||||
for(Min=RR,i=R[0];i;i=R[i])
|
||||
if(S[i]<Min) Min=S[i],c=i;
|
||||
for(i=D[c];i!=c;i=D[i])
|
||||
{
|
||||
remove(i);
|
||||
for(j=R[i];j!=i;j=R[j])
|
||||
{
|
||||
remove(j);
|
||||
}
|
||||
if(Dance(k+1)) return 1;
|
||||
for(j=L[i];j!=i;j=L[j])
|
||||
resume(j);
|
||||
resume(i);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
double dis(double x1,double y1,double x2,double y2)
|
||||
{
|
||||
return sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
|
||||
}
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
return *(int *)a - *(int *)b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,ncase,r,k,bit,sum;
|
||||
double left,right,mid,ansx,ansy,ans,num;
|
||||
point a,b;
|
||||
scanf("%d",&ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%lf%lf",&s[i].x,&s[i].y);
|
||||
left=0.0;
|
||||
right=7.1;
|
||||
ans=7.1;
|
||||
while(right>=left)
|
||||
{
|
||||
for(i=0;i<=n;i++)
|
||||
{
|
||||
S[i]=0;
|
||||
U[i]=D[i]=i;
|
||||
L[i+1]=i;R[i]=i+1;
|
||||
}R[n]=0;
|
||||
size=n+1;
|
||||
memset(H,-1,sizeof(H));
|
||||
memset(hash,0,sizeof(hash));
|
||||
mid=(left+right)/2;
|
||||
r=0;
|
||||
sum=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
ansx=s[i].x;ansy=s[i].y;
|
||||
bit=0;
|
||||
for(j=1;j<=n;j++)
|
||||
if(dis(s[j].x,s[j].y,ansx,ansy)<=mid) bit+=dir[j-1];
|
||||
if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;}
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=i+1;j<=n;j++)
|
||||
{
|
||||
num=dis(s[i].x,s[i].y,s[j].x,s[j].y);
|
||||
if(num<2*mid)
|
||||
{
|
||||
a.x=s[i].x;a.y=s[i].y;
|
||||
b.x=s[j].x;b.y=s[j].y;
|
||||
cnt=fun(a,b,mid);
|
||||
ansx=(a.x+b.x)/2;
|
||||
ansy=(a.y+b.y)/2;
|
||||
cnt1.x=2*ansx-cnt.x;
|
||||
cnt1.y=2*ansy-cnt.y;
|
||||
bit=0;
|
||||
for(k=1;k<=n;k++)
|
||||
{
|
||||
if(k==i) {bit+=dir[i-1];continue;}
|
||||
if(k==j) {bit+=dir[j-1];continue;}
|
||||
if(dis(s[k].x,s[k].y,cnt.x,cnt.y)<=mid) bit+=dir[k-1];
|
||||
}
|
||||
if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;}
|
||||
bit=0;
|
||||
for(k=1;k<=n;k++)
|
||||
{
|
||||
if(k==i) {bit+=dir[i-1];continue;}
|
||||
if(k==j) {bit+=dir[j-1];continue;}
|
||||
if(dis(s[k].x,s[k].y,cnt1.x,cnt1.y)<=mid) bit+=dir[k-1];
|
||||
}
|
||||
if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;}
|
||||
}
|
||||
else if(num==2*mid)
|
||||
{
|
||||
ansx=(s[i].x+s[j].x)/2;
|
||||
ansy=(s[i].y+s[j].y)/2;
|
||||
bit=0;
|
||||
for(k=1;k<=n;k++)
|
||||
{
|
||||
if(k==i) {bit+=dir[i-1];continue;}
|
||||
if(k==j) {bit+=dir[j-1];continue;}
|
||||
if(dis(s[k].x,s[k].y,ansx,ansy)<=mid) bit+=dir[k-1];
|
||||
}
|
||||
if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;}
|
||||
}
|
||||
}
|
||||
}
|
||||
qsort(st+1,sum,sizeof(st[1]),cmp);
|
||||
for(i=sum;i>=1;i--)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
if(st[i]&dir[j-1]) hash[st[i]-dir[j-1]]=0;
|
||||
if(hash[st[i]]==0) continue;
|
||||
r++;
|
||||
for(j=1;j<=n;j++)
|
||||
if(st[i]&dir[j-1]) {Link(r,j);hash[dir[j-1]]=0;}
|
||||
}
|
||||
if(Dance(0)) {ans=mid;right=mid-eps;}
|
||||
else left=mid+eps;
|
||||
}
|
||||
printf("%.6lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#define inf 0x7fffffff
|
||||
using namespace std;
|
||||
const int maxn=600;
|
||||
const int M = 100000+10;
|
||||
struct Edge
|
||||
{
|
||||
int to,cap,next;
|
||||
}edge[M*2];
|
||||
int head[maxn],edgenum;
|
||||
int n,m,from,to,vnum,s,t;
|
||||
void add(int u,int v,int cap)
|
||||
{
|
||||
edge[edgenum].to=v;
|
||||
edge[edgenum].cap=cap;
|
||||
edge[edgenum].next=head[u];
|
||||
head[u]=edgenum++;
|
||||
edge[edgenum].to=u;
|
||||
edge[edgenum].cap=0;
|
||||
edge[edgenum].next=head[v];
|
||||
head[v]=edgenum++;
|
||||
}
|
||||
int level[maxn];
|
||||
int gap[maxn];
|
||||
void bfs(int to)
|
||||
{
|
||||
memset(level,-1,sizeof(level));
|
||||
memset(gap,0,sizeof(gap));
|
||||
level[to]=0;
|
||||
gap[level[to] ]++;
|
||||
queue<int> Q;
|
||||
Q.push(to);
|
||||
while (!Q.empty())
|
||||
{
|
||||
int u=Q.front() ;Q.pop() ;
|
||||
for (int i=head[u] ;i!=-1 ;i=edge[i].next)
|
||||
{
|
||||
int v=edge[i].to;
|
||||
if (level[v] != -1) continue;
|
||||
level[v]=level[u]+1;
|
||||
gap[level[v] ]++;
|
||||
Q.push(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
int cur[maxn];
|
||||
int pre[maxn];
|
||||
int SAP(int from,int to)
|
||||
{
|
||||
bfs(to);
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memcpy(cur,head,sizeof(head));
|
||||
int u=pre[from]=from,flow=0,aug=inf;
|
||||
gap[from]=vnum;
|
||||
while (level[from]<vnum)
|
||||
{
|
||||
bool flag=false;
|
||||
for (int &i=cur[u] ;i!=-1 ;i=edge[i].next)
|
||||
{
|
||||
int v=edge[i].to;
|
||||
if (edge[i].cap && level[u]==level[v]+1)
|
||||
{
|
||||
flag=true;
|
||||
aug=min(aug,edge[i].cap);
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if (v==to)
|
||||
{
|
||||
flow += aug;
|
||||
for (u=pre[u] ;v!=from ;v=u ,u=pre[u])
|
||||
{
|
||||
edge[cur[u] ].cap -= aug;
|
||||
edge[cur[u]^1 ].cap += aug;
|
||||
}
|
||||
aug=inf;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (flag) continue;
|
||||
int minlevel=vnum;
|
||||
for (int i=head[u] ;i!=-1 ;i=edge[i].next)
|
||||
{
|
||||
int v=edge[i].to;
|
||||
if (edge[i].cap && level[v]<minlevel)
|
||||
{
|
||||
minlevel=level[v];
|
||||
cur[u]=i;
|
||||
}
|
||||
}
|
||||
if (--gap[level[u] ]==0) break;
|
||||
level[u]=minlevel+1;
|
||||
gap[level[u] ]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return flow;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
if (!n && !m) break;
|
||||
memset(head,-1,sizeof(head));
|
||||
edgenum=0;
|
||||
char c[5],c2[5];
|
||||
int u,v;
|
||||
int cap,f=M;
|
||||
s=0 ;t=n+1 ;from=t+1 ;to=from+1 ;
|
||||
vnum=to+1;
|
||||
int sum=0;
|
||||
for (int i=0 ;i<m ;i++)
|
||||
{
|
||||
scanf("%s%s%d",&c,&c2,&cap);
|
||||
sum += cap;
|
||||
if (c[0]=='+') u=s;
|
||||
else sscanf(c,"%d",&u);
|
||||
if (c2[0]=='-') v=t;
|
||||
else sscanf(c2,"%d",&v);
|
||||
add(u,v,f-cap);
|
||||
add(from,v,cap);
|
||||
add(u,to,cap);
|
||||
}
|
||||
int Maxflow=SAP(from,to);
|
||||
int d=edgenum;
|
||||
add(t,s,inf);
|
||||
Maxflow += SAP(from,to);
|
||||
int flag=0;
|
||||
for (int i=head[from] ;i!=-1 ;i=edge[i].next)
|
||||
{
|
||||
if (edge[i].cap) {flag=1;break; }
|
||||
}
|
||||
if (Maxflow==sum) printf("%d\n",edge[(d^1)].cap);
|
||||
else printf("impossible\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const double dd = sqrt(2.0)/2*10;
|
||||
int ti;
|
||||
double x,y;
|
||||
double d;
|
||||
double dis(double x1, double y1, double x2, double y2)
|
||||
{
|
||||
return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
|
||||
}
|
||||
void dfs(double x1,double y1,int dir,int tt)
|
||||
{
|
||||
double aa;
|
||||
dir %= 8;
|
||||
aa=dis(x1,y1,x,y);
|
||||
if(aa < d)
|
||||
{
|
||||
d = aa;
|
||||
}
|
||||
if(tt==ti ||(aa-10*(ti-tt)>d))
|
||||
{
|
||||
return ;
|
||||
}
|
||||
if(dir == 0)
|
||||
{
|
||||
dfs(x1+10,y1,dir,tt+1);
|
||||
}
|
||||
else if(dir == 1)
|
||||
{
|
||||
dfs(x1+dd,y1-dd,dir,tt+1);
|
||||
}
|
||||
else if(dir == 2)
|
||||
{
|
||||
dfs(x1,y1-10,dir,tt+1);
|
||||
}
|
||||
else if(dir == 3)
|
||||
{
|
||||
dfs(x1-dd,y1-dd,dir,tt+1);
|
||||
}
|
||||
else if(dir == 4)
|
||||
{
|
||||
dfs(x1-10,y1,dir,tt+1);
|
||||
}
|
||||
else if(dir == 5)
|
||||
{
|
||||
dfs(x1-dd,y1+dd,dir,tt+1);
|
||||
}
|
||||
else if(dir == 6)
|
||||
{
|
||||
dfs(x1,y1+10,dir,tt+1);
|
||||
}
|
||||
else if(dir == 7)
|
||||
{
|
||||
dfs(x1+dd,y1+dd,dir,tt+1);
|
||||
}
|
||||
dfs(x1,y1,dir+1,tt+1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%lf%lf",&ti,&x,&y);
|
||||
d = dis(0,0,x,y);
|
||||
dfs(0,0,0,0);
|
||||
printf("%.6lf\n",d);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
Digit 7 3 segments lit = 15 milliamps
|
||||
Digit 9 6 segments lit = 30 milliamps
|
||||
Digit 8 7 segments lit = 35 milliamps
|
||||
Total = 80 milliamps
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int MAXN = 15+2;
|
||||
int id[32786];
|
||||
char s[MAXN][MAXN];
|
||||
int gmax(int a,int b){return a>b?a:b;}
|
||||
int gmin(int a,int b){return a<b?a:b;}
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
id[0] = 0;
|
||||
for(i=0; i<=32786; i++){///浜杩惰〃绀轰涓
|
||||
id[i] = id[i>>1] + (i&1);
|
||||
}
|
||||
while(scanf("%s",s[0])!=EOF){
|
||||
if(s[0][0]=='E')
|
||||
return 0;
|
||||
for(i=1; i<15; i++){
|
||||
scanf("%s",s[i]);
|
||||
}
|
||||
int ans = 15;
|
||||
for(i=0; i<(1<<15); i++){
|
||||
int col[15];
|
||||
memset(col,0,sizeof(col));
|
||||
for(j=0; j<15; j++){
|
||||
if((i&(1<<j))==0){
|
||||
for(k=0; k<15; k++)
|
||||
if(s[j][k]=='#')
|
||||
col[k] = 1;
|
||||
}
|
||||
}
|
||||
int tt = 0;
|
||||
for(j=0; j<15; j++)
|
||||
if(col[j]==1)
|
||||
tt++;
|
||||
tt = gmax(id[i],tt);
|
||||
ans = gmin(ans,tt);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
double eps = 1e-8;
|
||||
bool cal(double n){
|
||||
if(1-n < eps)
|
||||
return true;
|
||||
int inter;
|
||||
double now, org = n;
|
||||
while(1){
|
||||
inter = n * 3;
|
||||
if(inter == 1)
|
||||
return false;
|
||||
n = n * 3 - inter;
|
||||
if(fabs(org - n) < eps)
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double n;
|
||||
char temp[10];
|
||||
while(scanf("%s", temp) != EOF && temp[0] != 'E'){
|
||||
sscanf(temp, "%lf", &n);
|
||||
if(cal(n))
|
||||
puts("MEMBER");
|
||||
else
|
||||
puts("NON-MEMBER");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
template<class T> inline void checkmax(T &a, T b)
|
||||
{if (b > a) a = b;}
|
||||
template<class T> inline void checkmin(T &a, T b)
|
||||
{if (b < a) a = b;}
|
||||
inline double sqr(double x)
|
||||
{return x * x;}
|
||||
struct Point {
|
||||
double x, y;
|
||||
} pt[35];
|
||||
int n;
|
||||
double tx, ty, v, c, sx, sy, dx, dy;
|
||||
double get(double p)
|
||||
{
|
||||
double cx = sx + dx * p;
|
||||
double cy = sy + dy * p;
|
||||
double cur = cy / v + sqrt(sqr(cx - tx) + sqr(cy - ty)) / c;
|
||||
return cur;
|
||||
}
|
||||
int ansidx;
|
||||
double ansp;
|
||||
void work()
|
||||
{
|
||||
for (int i = 1; i <= n; ++i) scanf("%lf%lf", &pt[i].x, &pt[i].y);
|
||||
pt[n + 1] = pt[1];
|
||||
double ans = 1e9;
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
dx = pt[i + 1].x - pt[i].x;
|
||||
dy = pt[i + 1].y - pt[i].y;
|
||||
sx = pt[i].x;
|
||||
sy = pt[i].y;
|
||||
for (int iter = 1; iter <= 35; ++iter) {
|
||||
double p = 0;
|
||||
for (double len = 1; len > 1e-9; len /= 1.5) for (int iter1 = 1; iter1 <= 35; ++iter1) {
|
||||
if (rand() & 1) p += len; else p -= len;
|
||||
checkmax(p, 0.0);
|
||||
checkmin(p, 1.0);
|
||||
double tmp = get(p);
|
||||
if (tmp < ans) {
|
||||
ans = tmp;
|
||||
ansidx = i;
|
||||
ansp = p;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
double trueans = ans;
|
||||
ansp -= 5000 * 1e-7;
|
||||
for (int i = 0; i < 10000; ++i, ansp += 1e-7) {
|
||||
dx = pt[ansidx + 1].x - pt[ansidx].x;
|
||||
dy = pt[ansidx + 1].y - pt[ansidx].y;
|
||||
sx = pt[ansidx].x;
|
||||
sy = pt[ansidx].y;
|
||||
if (ansp > -1e-7 && ansp < 1 + 1e-7) checkmin(trueans, get(ansp));
|
||||
}
|
||||
printf("%0.4lf\n", trueans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (scanf("%d%lf%lf%lf%lf", &n, &tx, &ty, &v, &c), n) work();
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
int d[1000050]={1};
|
||||
int f(int i)
|
||||
{
|
||||
if(d[i]==0)
|
||||
{
|
||||
double a=sin(i);
|
||||
d[i]=f((int)(i-sqrt(i+0.0)))+f((int)log(i+0.0))+f((int)(i*a*a));
|
||||
d[i]%=1000000;
|
||||
}
|
||||
return d[i];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)&&n!=-1)
|
||||
{
|
||||
printf("%d\n",f(n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include <memory.h>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
const int MAX=2005,INF=1<<30;
|
||||
int a[MAX],c[MAX],
|
||||
n,len;
|
||||
int bsearchLDS(const int &v){
|
||||
int l=1,r=len+1,m;
|
||||
while(l<r){
|
||||
m=l+(r-l)/2;
|
||||
if(c[m]>v) l=m+1;
|
||||
else r=m;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
int bsearchLIS(const int &v){
|
||||
int l=1,r=len+1,m;
|
||||
while(l<r){
|
||||
m=l+(r-l)/2;
|
||||
if(c[m]<v) l=m+1;
|
||||
else r=m;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
int LDS(const int &i){
|
||||
int pos;
|
||||
len=1;
|
||||
c[len]=a[i];
|
||||
for(int j=i+1;j<n;j++){
|
||||
pos=bsearchLDS(a[j]);
|
||||
if(pos==1)
|
||||
continue;
|
||||
c[pos]=a[j];
|
||||
if(pos>len)
|
||||
len=pos;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
int LIS(const int &i){
|
||||
int pos;
|
||||
len=1;
|
||||
c[len]=a[i];
|
||||
for(int j=i+1;j<n;j++){
|
||||
pos=bsearchLIS(a[j]);
|
||||
if(pos==1)
|
||||
continue;
|
||||
c[pos]=a[j];
|
||||
if(pos>len)
|
||||
len=pos;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int nCase,t1,t2,l,maxVal;
|
||||
while(cin>>n){
|
||||
maxVal=0;
|
||||
for(int i=0;i<n;i++)
|
||||
cin>>a[i];
|
||||
for(int i=0;i<n;i++){
|
||||
t1=LDS(i);
|
||||
t2=LIS(i);
|
||||
l=t1+t2-1;
|
||||
if(l>maxVal)
|
||||
maxVal=l;
|
||||
}
|
||||
cout<<maxVal<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <iostream>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAX=1000005,MAXN=105,INF=1<<30;
|
||||
int n,b,c;
|
||||
int has[MAXN],
|
||||
pos[MAX];
|
||||
int main()
|
||||
{
|
||||
bool endFlag;
|
||||
int u,v,p,adv,ft;
|
||||
while(scanf("%d %d %d",&n,&b,&c)==3){
|
||||
memset(has,0,sizeof(has));
|
||||
for(int i=0;i<n;i++) pos[i]=1;
|
||||
for(int i=0;i<b;i++){
|
||||
scanf("%d %d",&u,&v);
|
||||
has[u]=v;
|
||||
}
|
||||
endFlag=0;
|
||||
for(int i=0;i<c;i++){
|
||||
scanf("%d",&ft);
|
||||
if(endFlag){
|
||||
continue;
|
||||
}
|
||||
p=i%n;
|
||||
adv=pos[p]+ft;
|
||||
if(has[adv])
|
||||
adv=has[adv];
|
||||
if(adv<=100)
|
||||
pos[p]=adv;
|
||||
else
|
||||
pos[p]=100;
|
||||
if(pos[p]==100){
|
||||
endFlag=1;
|
||||
}
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
printf("Position of player %d is %d.\n",i+1,pos[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
CE is forward of CLR by N units.
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
inline
|
||||
double solve(double S, double T, double C, double t)
|
||||
{
|
||||
return T / C * (-log(S / C - t)) - 9.8 * t;
|
||||
}
|
||||
const double E = 1e-12;
|
||||
inline
|
||||
int dblcmp(double x)
|
||||
{
|
||||
if (x > -E && x < E)
|
||||
return 0;
|
||||
return x > 0 ? 1 : -1;
|
||||
}
|
||||
struct NN {
|
||||
long long S, L, T, C;
|
||||
};
|
||||
NN aa[1010];
|
||||
double dp[2][10100];
|
||||
int main()
|
||||
{
|
||||
int cn, cns;
|
||||
while (scanf("%d", &cns) == 1) {
|
||||
for (cn = 0; cn < cns; cn++) {
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
for (int i = 1; i <= n; i++) {
|
||||
scanf("%I64d%I64d%I64d%I64d", &aa[i].S, &aa[i].L, &aa[i].T, &aa[i].C);
|
||||
}
|
||||
for (int j = 0; j <= 10000; j++) {
|
||||
dp[0][j] = 0;
|
||||
}
|
||||
double maxv = 0;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 0; j <= 10000; j++) {
|
||||
int xx = i % 2, yy = (i - 1) % 2;
|
||||
dp[xx][j] = 0;
|
||||
dp[xx][j] = max(dp[xx][j], dp[yy][j]);
|
||||
if (j >= aa[i].S + aa[i].L && (aa[i].T - 9.8 * j) >= 0)
|
||||
dp[xx][j] = max(dp[xx][j], dp[yy][j - aa[i].S - aa[i].L]
|
||||
+ solve(j, aa[i].T, aa[i].C, (double)aa[i].L / aa[i].C) - solve(j, aa[i].T, aa[i].C, 0));
|
||||
if (maxv < dp[xx][j]) {
|
||||
maxv = dp[xx][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%.0lf\n", floor(maxv + 0.5));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include<iostream>
|
||||
#include<map>
|
||||
using namespace std;
|
||||
int gx[200005],sz[200005];
|
||||
char s1[200005][25],s2[200005][25];
|
||||
int find(int p)
|
||||
{
|
||||
if(p!=gx[p])
|
||||
{
|
||||
gx[p]=find(gx[p]);
|
||||
}
|
||||
return gx[p];
|
||||
}
|
||||
int unions(int p,int q)
|
||||
{
|
||||
int i=find(p),j=find(q);
|
||||
if(i==j) return sz[j];
|
||||
gx[i]=j;
|
||||
sz[j]+=sz[i];
|
||||
return sz[j];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,f,num,i;
|
||||
map<string,int>mymap;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
while(n--)
|
||||
{
|
||||
scanf("%d",&f);
|
||||
mymap.clear();
|
||||
num=0;
|
||||
for(i=1;i<=f;i++)
|
||||
{
|
||||
scanf("%s%s",s1[i],s2[i]);
|
||||
if(!mymap[s1[i]]) mymap[s1[i]]=++num;
|
||||
if(!mymap[s2[i]]) mymap[s2[i]]=++num;
|
||||
}
|
||||
for(i=1;i<=num;i++)
|
||||
{
|
||||
gx[i]=i;
|
||||
sz[i]=1;
|
||||
}
|
||||
for(i=1;i<=f;i++)
|
||||
printf("%d\n",unions(mymap[s1[i]],mymap[s2[i]]));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
fd 100 lt 120 fd 100 lt 120 fd 100
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#include"iostream"
|
||||
#include"cstdio"
|
||||
#include"cstring"
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
printf("...............................................................................................\n");
|
||||
printf("..#.........................#...........#.........................#............................\n");
|
||||
printf(".#...#####...#...........#...#.........#...#####...#...........#...#..............#####...#....\n");
|
||||
printf("#........#...#.....#.....#....#.......#........#...#...........#....#.................#...#....\n");
|
||||
printf("#.......#....#.....#.....#....#.......#.......#....#...........#....#....#####.......#....#....\n");
|
||||
printf("#......#.....#...#####...#....#...#...#......#.....#...#####...#....#...............#.....#....\n");
|
||||
printf("#.....#......#.....#.....#....#.......#.....#......#...........#....#....#####.....#......#....\n");
|
||||
printf("#.....#......#.....#.....#....#.......#.....#......#...........#....#..............#...........\n");
|
||||
printf(".#....#......#...........#....#........#....#......#...........#....#..............#......#....\n");
|
||||
printf("..#..........................#..........#..........................#...........................\n");
|
||||
printf("...............................................................................................\n");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int a[1005],b[1005];
|
||||
int i,j,e;
|
||||
int n,v,c;
|
||||
cin>>n;
|
||||
for(e=1;e<=n;e++)
|
||||
{
|
||||
cin>>v>>c;
|
||||
for(i=0;i<c;i++)
|
||||
{
|
||||
cin>>a[i]>>b[i];
|
||||
}
|
||||
for(i=0;i<c-1;i++)
|
||||
for(j=i+1;j<c;j++)
|
||||
if(b[i]-a[i]<b[j]-a[j])
|
||||
{
|
||||
swap(a[i],a[j]);
|
||||
swap(b[i],b[j]);
|
||||
}
|
||||
for(i=0;i<c;i++)
|
||||
{
|
||||
if(v>=b[i])
|
||||
{
|
||||
v=v-a[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
v=-1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(v==-1)
|
||||
{
|
||||
cout<<"No"<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<"Yes"<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
#define N 1005
|
||||
#define L 0.0000001
|
||||
double a[N];
|
||||
double b[N];
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
int i = 0;
|
||||
for(i = 1; i <= n; i++)
|
||||
scanf("%lf%lf",&a[i],&b[i]);
|
||||
int p1,p2;
|
||||
scanf("%d%d",&p1,&p2);
|
||||
double x1 = a[p2] - a[p1];
|
||||
double y1 = b[p2] - b[p1];
|
||||
for(i = 1; i <= n; i++)
|
||||
{
|
||||
double x2 = a[i] - a[p1];
|
||||
double y2 = b[i] - b[p1];
|
||||
double sum = x1*y2 - x2*y1;
|
||||
if(sum < -L)
|
||||
printf("Right\n");
|
||||
else if(sum > L)
|
||||
printf("Left\n");
|
||||
else printf("On\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
int a[10002];
|
||||
int dg(long n)
|
||||
{
|
||||
if(n==1||n==2||n==0)
|
||||
return 0;
|
||||
if(n%2==0)
|
||||
return dg(n/2)*2;
|
||||
else
|
||||
return dg(n/2)+dg(n-n/2)+1;
|
||||
}
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
int n;
|
||||
int i;
|
||||
long num;
|
||||
scanf("%d", &n);
|
||||
memset(a,-1, sizeof(a));
|
||||
a[0]=a[1]=a[2]= 0;
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%ld", &num);
|
||||
printf("%ld\n", dg(num));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <sstream>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#define cler(arr, val) memset(arr, val, sizeof(arr))
|
||||
typedef long long LL;
|
||||
const int MAXN = 15;
|
||||
const int MAXM = 6000010;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int mod = 1000000007;
|
||||
int val[MAXN],cost[1<<MAXN],E[MAXN],last[MAXN];
|
||||
int dp[1<<MAXN];
|
||||
vector<int>G[MAXN];
|
||||
int n,m;
|
||||
void init()
|
||||
{
|
||||
cler(last,0);
|
||||
cler(cost,0);
|
||||
cler(dp,-1);
|
||||
for(int i=0;i<n;i++)
|
||||
G[i].clear();
|
||||
for(int i=0;i<(1<<n);i++)
|
||||
{
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
if(i&(1<<j))
|
||||
cost[i]+=E[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
bool ok(int x,int p)
|
||||
{
|
||||
if((x&last[p])==last[p]&&cost[x]+E[p]<=m)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
cin>>n>>m;
|
||||
for(int i=0;i<n;i++) cin>>val[i];
|
||||
for(int i=0;i<n;i++) cin>>E[i];
|
||||
init();
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int x,y;
|
||||
scanf("%d",&x);
|
||||
while(x--)
|
||||
{
|
||||
cin>>y;
|
||||
y--;
|
||||
last[i]|=1<<y;
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
dp[0]=0;
|
||||
for(int i=0;i<(1<<n);i++)
|
||||
{
|
||||
if(dp[i]==-1) continue;
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
if(ok(i,j)&&(i&(1<<j))==0)
|
||||
{
|
||||
dp[(1<<j)|i]=dp[i]+val[j];
|
||||
ans=max(dp[(1<<j)|i],ans);
|
||||
}
|
||||
}
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
char s[1010];
|
||||
char ans[1020];
|
||||
int st[1010][20];
|
||||
int Min(int x,int y)
|
||||
{
|
||||
return s[x] <= s[y] ? x : y;
|
||||
}
|
||||
void RMQ_Init(int len)
|
||||
{
|
||||
for(int i = 0; i < len; i++)
|
||||
st[i][0] = i;
|
||||
for(int j = 1; (1<<j) < len; j++)
|
||||
for(int i = 0; i+(1<<j)-1 < len;i++)
|
||||
st[i][j] = Min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
|
||||
}
|
||||
int Query(int l,int r)
|
||||
{
|
||||
int k = (int)(log((double)(r-l+1))/log(2.0));
|
||||
return Min(st[l][k],st[r-(1<<k)+1][k]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int len, m, i;
|
||||
while(scanf("%s%d",s, &m)!=EOF)
|
||||
{
|
||||
len = strlen(s);
|
||||
RMQ_Init(len);
|
||||
m = len - m;
|
||||
int pos = 0, num = 0;
|
||||
while(m--)
|
||||
{
|
||||
pos = Query(pos, len - m - 1);
|
||||
ans[num++] = s[pos++];
|
||||
}
|
||||
for(i = 0; i < num; i++)
|
||||
if(ans[i]!='0')
|
||||
break;
|
||||
if(i == num)
|
||||
printf("0");
|
||||
else
|
||||
{
|
||||
while(i < num)
|
||||
printf("%c",ans[i++]);
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
int T,b;
|
||||
int ans;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d %d",&T,&b);
|
||||
ans = 0;
|
||||
if(90 % b)
|
||||
{
|
||||
cout<<"Impossible!"<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(T == 1 )
|
||||
{
|
||||
for(int i=9; i>=1; i--)
|
||||
{
|
||||
if(i % b == 0)
|
||||
{
|
||||
ans = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ans)
|
||||
{
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<"Impossible!"<<endl;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int i=99; i>=10; i--)
|
||||
{
|
||||
if(i % b == 0)
|
||||
{
|
||||
ans = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for(int k=3; k<=T; k++)
|
||||
{
|
||||
cout<<"9";
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#include<algorithm>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
#include<cmath>
|
||||
#include<string>
|
||||
#include<cstdlib>
|
||||
#include<vector>
|
||||
#include<cstdio>
|
||||
#include<set>
|
||||
#include<list>
|
||||
#include<numeric>
|
||||
#include<cassert>
|
||||
#include<ctime>
|
||||
using namespace std;
|
||||
vector<int> prime;
|
||||
int ans;
|
||||
bool isPrime(int n){
|
||||
for(int p = 2; p <= n/p ; p++){
|
||||
if(n % p == 0){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void dfs(int next, vector<int> with, int n){
|
||||
int nn = n;
|
||||
bool can = true;
|
||||
for(vector<int>::iterator it = with.begin() ; it != with.end() ; it++){
|
||||
if(n % (*it-1) == 0) {
|
||||
n /= (*it-1);
|
||||
}else {
|
||||
can = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(can){
|
||||
for(vector<int>::iterator it = with.begin() ; it != with.end() ; it++){
|
||||
while(n % *it == 0){
|
||||
n /= *it;
|
||||
}
|
||||
}
|
||||
if(n == 1)ans++;
|
||||
if(with.size() == 3){
|
||||
return;
|
||||
}
|
||||
for(int i = next ; i < prime.size(); i++){
|
||||
with.push_back(prime[i]);
|
||||
dfs(i+1, with, nn);
|
||||
with.pop_back();
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for(int n; ~scanf("%d", &n); ){
|
||||
prime.clear();
|
||||
for(int i = 1 ; i <= n / i; i++){
|
||||
if(n % i == 0){
|
||||
if(isPrime(i+1)){
|
||||
prime.push_back(i+1);
|
||||
}
|
||||
if(n/i != i && isPrime(n/i+1)){
|
||||
prime.push_back(n/i+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
ans = 0;
|
||||
dfs(0, vector<int>(), n);
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#include<stdio.h>
|
||||
int main()
|
||||
{
|
||||
int n,a,b,c;
|
||||
scanf("%d",&n);
|
||||
while(n--)
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b)
|
||||
printf("good\n");
|
||||
else if(a==b||a==c||b==c)
|
||||
printf("perfect\n");
|
||||
else
|
||||
printf("just a triangle\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#define maxn 1005
|
||||
using namespace std;
|
||||
int a[maxn];
|
||||
void csh()
|
||||
{
|
||||
int i;
|
||||
for(int i=1;i<=1000;i++)
|
||||
{
|
||||
int p=(int) sqrt(i);
|
||||
for(int j=1;j<=p;j++)
|
||||
{
|
||||
if(i%j==0)
|
||||
{
|
||||
if(j==i/j)
|
||||
a[i]++;
|
||||
else
|
||||
a[i]+=2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int answer(int b)
|
||||
{
|
||||
for(int i=1;i<=1000;i++)
|
||||
{
|
||||
if(a[i]==b)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
memset(a,0,sizeof(a));
|
||||
csh();
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
int k;
|
||||
cin>>k;
|
||||
int ans=answer(k);
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#define N 55
|
||||
#define M 10000
|
||||
#define inf 0x7fffffff
|
||||
using namespace std;
|
||||
int cnt[N][2],dis[N][2];
|
||||
bool h[N][2];
|
||||
int NE,head[N];
|
||||
int n,m;
|
||||
struct node{
|
||||
int next,v,w;
|
||||
node(){};
|
||||
node(int a,int b,int c){
|
||||
next=a;v=b;w=c;
|
||||
}
|
||||
}E[M];
|
||||
void init(){
|
||||
NE=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
}
|
||||
void insert(int u,int v,int w){
|
||||
E[NE]=node(head[u],v,w);
|
||||
head[u]=NE++;
|
||||
}
|
||||
void dijkstra(int beg,int end){
|
||||
for(int i=0;i<=n;i++){
|
||||
dis[i][0]=dis[i][1]=inf;
|
||||
cnt[i][0]=cnt[i][1]=0;
|
||||
}
|
||||
memset(h,0,sizeof(h));
|
||||
dis[beg][0]=0;
|
||||
cnt[beg][0]=1;
|
||||
while(true){
|
||||
int u,flag;
|
||||
int Min=inf;
|
||||
for(int i=0;i<n;i++){
|
||||
if(!h[i][0]&&dis[i][0]<Min){
|
||||
Min=dis[i][0];
|
||||
u=i;flag=0;
|
||||
}
|
||||
else if(!h[i][1]&&dis[i][1]<Min){
|
||||
Min=dis[i][1];
|
||||
u=i;flag=1;
|
||||
}
|
||||
}
|
||||
if(u==end&&flag==1) break;
|
||||
if(Min==inf) break;
|
||||
h[u][flag]=1;
|
||||
for(int i=head[u];i!=-1;i=E[i].next){
|
||||
int v=E[i].v;
|
||||
int w=dis[u][flag]+E[i].w;
|
||||
if(dis[v][0]>w){
|
||||
if(dis[v][0]!=inf){
|
||||
dis[v][1]=dis[v][0];
|
||||
cnt[v][1]=cnt[v][0];
|
||||
}
|
||||
dis[v][0]=w;
|
||||
cnt[v][0]=cnt[u][flag];
|
||||
}
|
||||
else if(dis[v][0]==w)
|
||||
cnt[v][0]+=cnt[u][flag];
|
||||
else if(dis[v][1]>w){
|
||||
dis[v][1]=w;
|
||||
cnt[v][1]=cnt[u][flag];
|
||||
}
|
||||
else if(dis[v][1]==w)
|
||||
cnt[v][1]+=cnt[u][flag];
|
||||
}
|
||||
}
|
||||
printf("%d %d\n",dis[end][1],cnt[end][1]);
|
||||
}
|
||||
int main(void){
|
||||
int s,t;
|
||||
while(~scanf("%d%d%d%d",&n,&m,&s,&t)){
|
||||
init();
|
||||
while(m--){
|
||||
int x,y,w;
|
||||
scanf("%d%d%d",&x,&y,&w);
|
||||
insert(x,y,w);
|
||||
}
|
||||
dijkstra(s,t);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN =10000+100;
|
||||
int a[MAXN];
|
||||
int dmin[MAXN][20];
|
||||
void initMin(int n,int d[])
|
||||
{
|
||||
for(int i=0; i<=n; i++)dmin[i][0]=d[i];
|
||||
for(int j=1; (1<<j)<=n; j++)
|
||||
for(int i=1; i+(1<<j)-1<=n; i++)
|
||||
dmin[i][j] = min(dmin[i][j-1] , dmin[i+(1<<(j-1))][j-1]);
|
||||
}
|
||||
int getMin(int L,int R)
|
||||
{
|
||||
int k=0;
|
||||
while((1<<(k+1))<=R-L+1)k++;
|
||||
return min(dmin[L][k] , dmin[R-(1<<k)+1][k]);
|
||||
}
|
||||
struct node
|
||||
{
|
||||
int p,d;
|
||||
bool operator <(const node &b)const
|
||||
{
|
||||
return p<b.p || (p==b.p && d<b.d);
|
||||
}
|
||||
} node1[MAXN],node2[MAXN];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)==1&&n)
|
||||
{
|
||||
for(int i =0; i<=10000+100; i++)
|
||||
a[i]=1000000;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
int p,d;
|
||||
scanf("%d%d",&p,&d);
|
||||
p++;
|
||||
d++;
|
||||
node1[i].p=p;
|
||||
node1[i].d=d;
|
||||
a[p] = min(a[p],d);
|
||||
}
|
||||
initMin(MAXN,a);
|
||||
int cnt=0;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
int p,d;
|
||||
p = node1[i].p;
|
||||
d = node1[i].d;
|
||||
if(p==1)
|
||||
{
|
||||
node2[++cnt] =node1[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
int d_min = getMin(1,p-1);
|
||||
if(d<=d_min)
|
||||
{
|
||||
node2[++cnt] =node1[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
sort(node2+1,node2+1+cnt);
|
||||
printf("%d\n",cnt);
|
||||
for(int i=1; i<=cnt; i++)
|
||||
printf("%d %d\n",node2[i].p-1,node2[i].d-1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
long long num[27];
|
||||
void cal()
|
||||
{
|
||||
int front=1,tail;
|
||||
long long wei=1;
|
||||
num[0]=0;
|
||||
while(1)
|
||||
{
|
||||
int k=front;
|
||||
tail=0;
|
||||
for(int i=1;i<10;i++)
|
||||
{
|
||||
for(int j=0;j<k;j++)
|
||||
{
|
||||
long long b=num[j]+i*wei,c=0;
|
||||
for(long long m=wei;m>0;m/=10)
|
||||
{
|
||||
long long d=(b/m-(b/(10*m))*10)*m,e=b%(10*wei/m);
|
||||
c+=(d*e);
|
||||
}
|
||||
c%=(wei*10);
|
||||
if(c==b)
|
||||
{
|
||||
num[front++]=b;
|
||||
if(front>25) return;
|
||||
}
|
||||
}
|
||||
}
|
||||
wei*=10;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cal();
|
||||
int n;
|
||||
while(scanf("%d",&n)==1)
|
||||
{
|
||||
printf("%I64d\n",num[n-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<stack>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
vector<int> V[1010];
|
||||
stack<int> S;
|
||||
int N;
|
||||
int dfs(int v,int pre) //涓寮
|
||||
{
|
||||
int i,t;
|
||||
int sum=0;
|
||||
for(i=0;i<V[v].size();i++)
|
||||
{
|
||||
t=V[v][i];
|
||||
if(t!=pre)
|
||||
sum=sum^(dfs(t,v)+1);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,flag,t;
|
||||
while(scanf("%d",&N)!=EOF)
|
||||
{
|
||||
for(i=0;i<=N;i++)
|
||||
V[i].clear();
|
||||
while(!S.empty())
|
||||
S.pop();
|
||||
for(i=0;i<N;i++)
|
||||
{
|
||||
scanf("%d",&t);
|
||||
if(t!=-1)
|
||||
{
|
||||
V[t].push_back(i);
|
||||
V[i].push_back(t);
|
||||
}
|
||||
else
|
||||
{
|
||||
S.push(i);
|
||||
}
|
||||
}
|
||||
int t,sum=0;
|
||||
while(!S.empty())
|
||||
{
|
||||
t=S.top();
|
||||
S.pop();
|
||||
sum=sum^dfs(t,-1);
|
||||
}
|
||||
if(sum)
|
||||
printf("YES\n");
|
||||
else
|
||||
printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
__int64 x[100001]={0};
|
||||
void set(__int64 p1,__int64 p2,__int64 p3,__int64 n)
|
||||
{
|
||||
__int64 a=1,b=1,c=1,k=2,s[3];
|
||||
x[1]=1;
|
||||
while(k<=n+1)
|
||||
{
|
||||
s[0]=x[a]*p1;s[1]=x[b]*p2;s[2]=x[c]*p3;
|
||||
sort(s,s+3);
|
||||
x[k]=s[0];
|
||||
if(n+1==k)printf("%I64d\n",x[k]);
|
||||
if(s[0]==x[a]*p1)
|
||||
a++;
|
||||
if(s[0]==x[b]*p2)
|
||||
b++;
|
||||
if(s[0]==x[c]*p3)
|
||||
c++;
|
||||
k++;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
__int64 p1,p2,p3,i;
|
||||
while(scanf("%I64d%I64d%I64d%I64d",&p1,&p2,&p3,&i)!=EOF)
|
||||
set(p1,p2,p3,i);
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue