KiritoTRw
GitHub
parent
34d0415174
commit
54568ca2fa
|
|
@ -0,0 +1,62 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 110
|
||||
#define INF (1e9)+5
|
||||
int graph[N][N],cut[N][N];
|
||||
int n;
|
||||
bool check(vector<int>v)
|
||||
{
|
||||
if(v.size()<=1) return true;
|
||||
int bridge=INF;
|
||||
for(int i=0;i<v.size();++i)
|
||||
for(int j=0;j<v.size();++j)
|
||||
bridge=min(bridge,cut[v[i]][v[j]]);
|
||||
vector<int>v0,v1;
|
||||
for(int i=0,x=v[0];i<v.size();++i)
|
||||
{
|
||||
if(cut[v[i]][x]>bridge) v0.push_back(v[i]);
|
||||
else v1.push_back(v[i]);
|
||||
}
|
||||
if(v0.empty()||v1.empty()) return false;
|
||||
for(int i=0;i<v0.size();++i)
|
||||
for(int j=0;j<v1.size();++j)
|
||||
{
|
||||
if(cut[v0[i]][v1[j]]!=bridge) return false;
|
||||
}
|
||||
graph[v0[0]][v1[0]]=graph[v1[0]][v0[0]]=bridge;
|
||||
return check(v0)&&check(v1);
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for(int i=1;i<=n;++i)
|
||||
{
|
||||
for(int j=1;j<=n;++j)
|
||||
scanf("%d",&cut[i][j]);
|
||||
cut[i][i]=INF;
|
||||
}
|
||||
memset(graph,0,sizeof(graph));
|
||||
vector<int>v;
|
||||
for(int i=1;i<=n;++i) v.push_back(i);
|
||||
if(check(v))
|
||||
{
|
||||
for(int i=1;i<=n;++i) graph[i][i]=-1;
|
||||
printf("YES\n");
|
||||
for(int i=1;i<=n;++i)
|
||||
for(int j=1;j<=n;++j)
|
||||
{
|
||||
printf("%d",graph[i][j]);
|
||||
if(j<n) printf(" ");
|
||||
else printf("\n");
|
||||
}
|
||||
}
|
||||
else printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
long long s[1000500];
|
||||
int main ()
|
||||
{
|
||||
int n,a,b;
|
||||
while(scanf("%d%d%d",&n,&a,&b)!=EOF)
|
||||
{
|
||||
for(int i=1;i<=n;++i)
|
||||
scanf("%I64d",&s[i]);
|
||||
for(int i=n-1;i>=1;--i)
|
||||
s[i]+=s[i+1];
|
||||
long long pre_min=0,now_min;
|
||||
for(int i=n;i>=1;--i)
|
||||
{
|
||||
now_min=pre_min+s[i];
|
||||
pre_min=min(pre_min,max(-s[i],a+b-s[1]+1-now_min));
|
||||
}
|
||||
if(a>=now_min)
|
||||
printf("ALICE\n");
|
||||
else printf("BOB\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<map>
|
||||
#include<stack>
|
||||
#include<set>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
typedef long long int64;
|
||||
typedef pair<int64,int64> PII;
|
||||
#define MP(a,b) make_pair((a),(b))
|
||||
const int maxn = 100015;
|
||||
const int inf = 0x7fffffff;
|
||||
const double pi=acos(-1.0);
|
||||
const double eps = 1e-8;
|
||||
const int64 mod = 1000000000+7;
|
||||
int64 Fast_Pow( int64 a,int64 n,int64 mod ){
|
||||
int64 res = 1;
|
||||
while( n>=1 ){
|
||||
if( n&1 ){
|
||||
res = res*a%mod;
|
||||
}
|
||||
a = a*a%mod;
|
||||
n >>= 1;
|
||||
}
|
||||
return res%mod;
|
||||
}
|
||||
int64 GetNum( char str[],int64 mod ){
|
||||
int64 res = 0;
|
||||
int len = strlen( str );
|
||||
for( int i=0;i<len;i++ ){
|
||||
res = (res*10+str[i]-'0')%mod;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
int main(){
|
||||
char str[ maxn ];
|
||||
while( scanf("%s",str)!=EOF ){
|
||||
int64 n = GetNum( str,mod-1 );
|
||||
printf("%I64d\n",Fast_Pow( 2,(n-1+mod)%mod,mod ));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 100100
|
||||
#pragma comment(linker, "/STACK:16777216")
|
||||
struct Edge{
|
||||
int v,next;
|
||||
}edge[MAXN*4];
|
||||
int NE;
|
||||
long long n;
|
||||
int head[MAXN];
|
||||
void Insert(int u,int v)
|
||||
{
|
||||
edge[NE].v=v;
|
||||
edge[NE].next=head[u];
|
||||
head[u]=NE++;
|
||||
}
|
||||
bool mark[MAXN];
|
||||
long long sum,ans;
|
||||
int dfs(int u)
|
||||
{
|
||||
mark[u]=true;
|
||||
int son,tmp=0;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(mark[v])continue;
|
||||
son=dfs(v);
|
||||
tmp+=son;
|
||||
ans+=(long long )(n-1-tmp)*son;
|
||||
}
|
||||
return tmp+1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int u,v;
|
||||
while(~scanf("%I64d",&n)){
|
||||
NE=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
for(int i=1;i<n;i++){
|
||||
scanf("%d%d",&u,&v);
|
||||
Insert(u,v);
|
||||
Insert(v,u);
|
||||
}
|
||||
memset(mark,false,sizeof(mark));
|
||||
ans=0;
|
||||
dfs(1);
|
||||
sum=n*(n-1)*(n-2)/6;
|
||||
printf("%I64d\n",sum-ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
a e
|
||||
bdf
|
||||
c g
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int next,to;
|
||||
int step;
|
||||
} a[100005];
|
||||
int head[100005];
|
||||
int n,d,len,ans;
|
||||
void add(int x,int y)
|
||||
{
|
||||
a[len].to = y;
|
||||
a[len].next = head[x];
|
||||
head[x] = len++;
|
||||
}
|
||||
void dfs(int x,int step)
|
||||
{
|
||||
int i,j,k;
|
||||
if(-1 == head[x])
|
||||
return ;
|
||||
for(i = head[x]; i!=-1; i = a[i].next)
|
||||
{
|
||||
k = a[i].to;
|
||||
a[i].step = step+1;
|
||||
if(a[i].step>d)
|
||||
ans++;
|
||||
dfs(k,a[i].step);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,i,j,x,y;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(a,0,sizeof(a));
|
||||
scanf("%d%d",&n,&d);
|
||||
len = 0;
|
||||
for(i = 1; i<n; i++)
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
add(x,y);
|
||||
}
|
||||
ans = 0;
|
||||
dfs(0,0);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
long long a[20][20];
|
||||
int n;
|
||||
void change(int &x,int &y,int k)
|
||||
{
|
||||
if(x == k)
|
||||
{
|
||||
if(y == k)
|
||||
{
|
||||
x++;
|
||||
}
|
||||
else y--;
|
||||
}
|
||||
else if(x == n+1-k)
|
||||
{
|
||||
if(y == n+1-k)
|
||||
x--;
|
||||
else y++;
|
||||
}
|
||||
else if(y == k)
|
||||
x++;
|
||||
else x--;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n) && n)
|
||||
{
|
||||
for(int i = 1;i <= n;i++)
|
||||
for(int j = 1;j <= n;j++)
|
||||
cin>>a[i][j];
|
||||
long long ans1 = 0, ans2 = 0;
|
||||
for(int i = 1;i <= n/2;i++)
|
||||
{
|
||||
int x0 = i,y0 = i;
|
||||
int x1 = i,y1 = n+1-i;
|
||||
int x2 = n+1-i,y2 = i;
|
||||
int x3 = n+1-i,y3 = n+1-i;
|
||||
int tmp1 = a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3];
|
||||
int tmp2 = 0;
|
||||
for(int j = 0;j < (n+2-2*i-2);j++)
|
||||
{
|
||||
change(x0,y0,i);
|
||||
change(x1,y1,i);
|
||||
change(x2,y2,i);
|
||||
change(x3,y3,i);
|
||||
int tt = min(j+1,n+2-2*i-1-(j+1));
|
||||
if(tmp1 < a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3])
|
||||
{
|
||||
tmp1 = a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3];
|
||||
tmp2 = tt;
|
||||
}
|
||||
else if(tmp1 == a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3] && tmp2 > tt)
|
||||
{
|
||||
tmp2 = tt;
|
||||
}
|
||||
}
|
||||
ans1 += tmp1;
|
||||
ans2 += tmp2;
|
||||
}
|
||||
ans1 += a[n/2+1][n/2+1];
|
||||
cout<<ans1<<" "<<ans2<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
struct point
|
||||
{
|
||||
double x;
|
||||
double y;
|
||||
};
|
||||
double area(point A,point B,point C)
|
||||
{
|
||||
double abx=B.x-A.x;
|
||||
double aby=B.y-A.y;
|
||||
double acx=C.x-A.x;
|
||||
double acy=C.y-A.y;
|
||||
double ans=(abx*acy-acx*aby)/2;
|
||||
return fabs(ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
cin>>T;
|
||||
while(T--)
|
||||
{
|
||||
cin>>n;
|
||||
point p[n];
|
||||
double x,y;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%lf %lf",&x,&y);
|
||||
p[i].x=x;
|
||||
p[i].y=y;
|
||||
}
|
||||
vector<double> v;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=i+1;j<n;j++)
|
||||
for(int k=j+1;k<n;k++)
|
||||
{
|
||||
v.push_back(area(p[i],p[j],p[k]));
|
||||
}
|
||||
sort(v.begin(),v.end());
|
||||
double ans=0;
|
||||
for(int i=0;i<v.size();i++)
|
||||
if(v[i]!=0)
|
||||
{
|
||||
ans=v[i];
|
||||
break;
|
||||
}
|
||||
if(ans==0) cout<<"Impossible"<<endl;
|
||||
else printf("%.2lf\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
#define MP(x,y) make_pair(x,y)
|
||||
const int MAXN= 110;
|
||||
const double EPS = 1e-14;
|
||||
const double INF = 1e50;
|
||||
long double dp[1010][MAXN];
|
||||
int fa[1010][MAXN],ord[1010];
|
||||
double pm[MAXN][MAXN],pw[MAXN][MAXN];
|
||||
int main()
|
||||
{
|
||||
int ncase,n,m,w;
|
||||
scanf("%d",&ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&w);
|
||||
for(int i=0;i<n;++i) scanf("%d",&ord[i]);
|
||||
for(int i=0;i<m;++i)
|
||||
for(int j=0;j<m;++j)
|
||||
{
|
||||
scanf("%lf",&pm[i][j]);
|
||||
if(pm[i][j]>EPS)
|
||||
pm[i][j]=log(pm[i][j]);
|
||||
else pm[i][j]=-INF;
|
||||
}
|
||||
for(int i=0;i<m;++i)
|
||||
for(int j=0;j<w;++j)
|
||||
{
|
||||
scanf("%lf",&pw[i][j]);
|
||||
if(pw[i][j]>EPS)
|
||||
pw[i][j]=log(pw[i][j]);
|
||||
else pw[i][j]=-INF;
|
||||
}
|
||||
for(int i=0;i<m;++i) dp[n-1][i]=pw[i][ord[n-1]];
|
||||
for(int i=n-2;i>=0;--i)
|
||||
{
|
||||
for(int j=0;j<m;++j) dp[i][j]=-INF;
|
||||
for(int j=0;j<m;++j)
|
||||
if(pw[j][ord[i]]>-INF+EPS)
|
||||
for(int k=0;k<m;++k)
|
||||
if(pm[j][k]>-INF+EPS&&dp[i][j]+EPS<dp[i+1][k]+pm[j][k]+pw[j][ord[i]])
|
||||
dp[i][j]=dp[i+1][k]+pm[j][k]+pw[j][ord[i]],fa[i][j]=k;
|
||||
}
|
||||
int pos=0;
|
||||
long double best=-INF;
|
||||
for(int i=0;i<m;++i)
|
||||
if(best+EPS<dp[0][i]+pm[0][i])
|
||||
best=dp[0][i]+pm[0][i],pos=i;
|
||||
printf("%d",pos);
|
||||
for(int i=0;i<n-1;++i)
|
||||
printf(" %d",pos=fa[i][pos]);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
#include<fstream>
|
||||
#include<sstream>
|
||||
#include<bitset>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#define FF(i, a, b) for(int i=a; i<b; i++)
|
||||
#define FD(i, a, b) for(int i=a; i>=b; i--)
|
||||
#define REP(i, n) for(int i=0; i<n; i++)
|
||||
#define CLR(a, b) memset(a, b, sizeof(a))
|
||||
#define LL long long
|
||||
#define PB push_back
|
||||
#define eps 1e-10
|
||||
using namespace std;
|
||||
const int maxn = 100010;
|
||||
const int INF = (1<<21) + 10;
|
||||
int T, n, a[maxn];
|
||||
int has[INF];
|
||||
char ch[10];
|
||||
int calc(char *ch)
|
||||
{
|
||||
int ret = 0;
|
||||
REP(i, 5)
|
||||
{
|
||||
if(isupper(ch[i])) ret = ret*16 + (ch[i]-'A') + 10;
|
||||
else ret = ret*16 + (ch[i]-'0');
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
bool dfs(int val, int now, int len, int num)
|
||||
{
|
||||
if(len == num)
|
||||
{
|
||||
REP(i, n) if(has[a[i]^val] == T) return true;
|
||||
return false;
|
||||
}
|
||||
FF(i, now, 21) if(dfs(val+(1<<i), i+1, len+1, num)) return true;
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncas;
|
||||
scanf("%d", &ncas);
|
||||
for(T=1; T<=ncas; T++)
|
||||
{
|
||||
scanf("%d", &n);
|
||||
bool flag = 0;
|
||||
REP(i, n)
|
||||
{
|
||||
scanf("%s", ch);
|
||||
a[i] = calc(ch);
|
||||
if(has[a[i]] == T) flag = 1;
|
||||
has[a[i]] = T;
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
puts("0");
|
||||
continue;
|
||||
}
|
||||
int ans = 1;
|
||||
while(!dfs(0, 0, 0, ans)) ans++;
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
p(p(....p(i)...)) = i
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 99999999
|
||||
using namespace std;
|
||||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
const int MAX=1000000+10;
|
||||
int head[MAX],size,sum=0;
|
||||
struct Edge{
|
||||
int v,next;
|
||||
Edge(){}
|
||||
Edge(int V,int NEXT):v(V),next(NEXT){}
|
||||
}edge[MAX*2];
|
||||
void Init(int num){
|
||||
memset(head,-1,sizeof(int)*(num+1));
|
||||
size=sum=0;
|
||||
}
|
||||
void InsertEdge(int u,int v){
|
||||
edge[size]=Edge(v,head[u]);
|
||||
head[u]=size++;
|
||||
}
|
||||
int dfs(int u,int father){
|
||||
int num=0,v;
|
||||
for(int i=head[u];i != -1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(v == father)continue;
|
||||
num+=dfs(v,u);
|
||||
}
|
||||
if(num>=2){
|
||||
if(u == 1)sum+=num-2;
|
||||
else sum+=num-1;
|
||||
return 0;
|
||||
}else return 1;
|
||||
}
|
||||
int main(){
|
||||
int t,n,u,v;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
Init(n);
|
||||
for(int i=1;i<n;++i){
|
||||
scanf("%d%d",&u,&v);
|
||||
InsertEdge(u,v);
|
||||
InsertEdge(v,u);
|
||||
}
|
||||
dfs(1,0);
|
||||
printf("%d\n",sum*2+1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MAX 1000005
|
||||
int is_prime[MAX];
|
||||
int num[MAX];
|
||||
int len;
|
||||
void Init() {
|
||||
memset(is_prime, 1, sizeof(is_prime));
|
||||
is_prime[0] = is_prime[1] = 0;
|
||||
for(int i=2; i<sqrt(MAX*1.0); i++) {
|
||||
if(is_prime[i]) {
|
||||
for(int j=i*i; j<MAX; j+=i) {
|
||||
is_prime[j] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
len = 0;
|
||||
for(int i=2; i<MAX; i++) {
|
||||
if(is_prime[i])
|
||||
num[len++] = i;
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int t;
|
||||
Init();
|
||||
scanf("%d",&t);
|
||||
while(t--) {
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
if(!n) puts("2 2");
|
||||
else if(n<0) {
|
||||
n = -1*n;
|
||||
int flag = 0;
|
||||
for(int i=0; i<len; i++) {
|
||||
if(is_prime[num[i]+n]) {
|
||||
flag = 1;
|
||||
printf("%d %d\n", num[i], num[i]+n);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!flag) printf("FAIL\n");
|
||||
}
|
||||
else {
|
||||
int flag = 0;
|
||||
for(int i=0; i<len; i++) {
|
||||
if(is_prime[num[i]+n]) {
|
||||
flag = 1;
|
||||
printf("%d %d\n", num[i]+n, num[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!flag) printf("FAIL\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
*------------*
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
|............|
|
||||
*------------*
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps=1e-14;
|
||||
const int maxn=303;
|
||||
int n;
|
||||
struct node{
|
||||
double x,y,vx,vy;
|
||||
}e[maxn*maxn];
|
||||
double cross(node a,node b,double t)
|
||||
{
|
||||
return (a.x+a.vx*t-b.x-b.vx*t)*(a.x+a.vx*t-b.x-b.vx*t)+(a.y+a.vy*t-b.y-b.vy*t)*(a.y+a.vy*t-b.y-b.vy*t);
|
||||
}
|
||||
double find(double t)
|
||||
{
|
||||
double ans=0;
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)
|
||||
for(j=i+1;j<n;j++)
|
||||
ans=max(ans,cross(e[i],e[j],t));
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,tt=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int i,j,k;
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%lf%lf%lf%lf",&e[i].x,&e[i].y,&e[i].vx,&e[i].vy);
|
||||
double l,r,m1,m2;
|
||||
l=0,r=1e8;
|
||||
for(i=0;i<100;i++)
|
||||
{
|
||||
m1=l+(r-l)/3;
|
||||
m2=r-(r-l)/3;
|
||||
if(find(m1)<find(m2)) r=m2;
|
||||
else l=m1;
|
||||
}
|
||||
printf("Case #%d: %.2lf %.2lf\n",++tt,l,sqrt(find(l)));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 100005
|
||||
int anc[MAXN][17];
|
||||
int LL[MAXN][17][2], RR[MAXN][17][2];
|
||||
int ans[MAXN][17][2];
|
||||
int dep[MAXN];
|
||||
struct EDGE
|
||||
{
|
||||
EDGE() {}
|
||||
EDGE(int _to, int _next) { to = _to, next = _next; }
|
||||
int to, next;
|
||||
}edge[MAXN];
|
||||
int edgecnt, head[MAXN];
|
||||
void init()
|
||||
{
|
||||
memset(anc, -1, sizeof(anc));
|
||||
memset(head, -1, sizeof(head));
|
||||
edgecnt = 0;
|
||||
}
|
||||
void add(int s, int t)
|
||||
{
|
||||
edge[edgecnt] = EDGE(t, head[s]);
|
||||
head[s] = edgecnt++;
|
||||
}
|
||||
int val[MAXN];
|
||||
void dfs(int u, int fa, int deep)
|
||||
{
|
||||
anc[u][0] = fa;
|
||||
dep[u] = deep;
|
||||
if (val[u] < val[fa])
|
||||
{
|
||||
LL[u][0][0] = 2;
|
||||
LL[u][0][1] = 1;
|
||||
RR[u][0][0] = 2;
|
||||
RR[u][0][1] = 1;
|
||||
ans[u][0][0] = 2;
|
||||
ans[u][0][1] = 1;
|
||||
}
|
||||
else if (val[u]>val[fa])
|
||||
{
|
||||
LL[u][0][0] = 1;
|
||||
LL[u][0][1] = 2;
|
||||
RR[u][0][0] = 1;
|
||||
RR[u][0][1] = 2;
|
||||
ans[u][0][0] = 1;
|
||||
ans[u][0][1] = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
LL[u][0][0] = LL[u][0][1] = RR[u][0][0] = RR[u][0][1] = ans[u][0][0] = ans[u][0][1] = 1;
|
||||
}
|
||||
for (int i = head[u]; ~i; i = edge[i].next) dfs(edge[i].to, u, deep + 1);
|
||||
}
|
||||
void process(int n)
|
||||
{
|
||||
for (int j = 0; j < 16; j++)
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
if (dep[anc[i][j]]>(1 << j))
|
||||
{
|
||||
anc[i][j + 1] = anc[anc[i][j]][j];
|
||||
int A = anc[i][j];
|
||||
int len = (1 << j) + 1;
|
||||
if (LL[i][j][0] == len) LL[i][j + 1][0] = len - 1 + LL[A][j][0];
|
||||
else LL[i][j + 1][0] = LL[i][j][0];
|
||||
if (RR[A][j][0] == len) RR[i][j + 1][0] = len - 1 + RR[i][j][0];
|
||||
else RR[i][j + 1][0] = RR[A][j][0];
|
||||
if (LL[i][j][1] == len) LL[i][j + 1][1] = len - 1 + LL[A][j][1];
|
||||
else LL[i][j + 1][1] = LL[i][j][1];
|
||||
if (RR[A][j][1] == len) RR[i][j + 1][1] = len - 1 + RR[i][j][1];
|
||||
else RR[i][j + 1][1] = RR[A][j][1];
|
||||
ans[i][j + 1][0] = max(ans[i][j][0], ans[A][j][0]);
|
||||
ans[i][j + 1][0] = max(ans[i][j + 1][0], RR[i][j][0] + LL[A][j][0] - 1);
|
||||
ans[i][j + 1][1] = max(ans[i][j][1], ans[A][j][1]);
|
||||
ans[i][j + 1][1] = max(ans[i][j + 1][1], RR[i][j][1] + LL[A][j][1] - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
int lca(int u, int v)
|
||||
{
|
||||
if (dep[u] < dep[v]) swap(u, v);
|
||||
for (int i = 16; i >= 0; i--) if (dep[u] - (1 << i) >= dep[v]) u = anc[u][i];
|
||||
if (u == v) return u;
|
||||
for (int i = 16; i >= 0; i--)
|
||||
if (anc[u][i] != anc[v][i])
|
||||
{
|
||||
u = anc[u][i];
|
||||
v = anc[v][i];
|
||||
}
|
||||
return anc[u][0];
|
||||
}
|
||||
int getans(int u, int v)
|
||||
{
|
||||
int l = lca(u, v);
|
||||
int Ru = 1, ansu = 1;
|
||||
bool first = 1;
|
||||
for (int i = 16; i >= 0; i--)
|
||||
if (dep[u] - (1 << i) >= dep[l])
|
||||
{
|
||||
if (first)
|
||||
{
|
||||
Ru = RR[u][i][0];
|
||||
ansu = ans[u][i][0];
|
||||
first = 0;
|
||||
u = anc[u][i];
|
||||
continue;
|
||||
}
|
||||
ansu = max(ansu, ans[u][i][0]);
|
||||
ansu = max(ansu, Ru + LL[u][i][0] - 1);
|
||||
int len = (1 << i) + 1;
|
||||
if (len == RR[u][i][0]) Ru += RR[u][i][0] - 1;
|
||||
else Ru = RR[u][i][0];
|
||||
u = anc[u][i];
|
||||
}
|
||||
int Rv = 1, ansv = 1;
|
||||
first = 1;
|
||||
for (int i = 16; i >= 0; i--)
|
||||
if (dep[v] - (1 << i) >= dep[l])
|
||||
{
|
||||
if (first)
|
||||
{
|
||||
Rv = RR[v][i][1];
|
||||
ansv = ans[v][i][1];
|
||||
first = 0;
|
||||
v = anc[v][i];
|
||||
continue;
|
||||
}
|
||||
ansv = max(ansv, ans[v][i][1]);
|
||||
ansv = max(ansv, Rv + LL[v][i][1] - 1);
|
||||
int len = (1 << i) + 1;
|
||||
if (len == RR[v][i][1]) Rv += RR[v][i][1] - 1;
|
||||
else Rv = RR[v][i][1];
|
||||
v = anc[v][i];
|
||||
}
|
||||
int ans = max(ansu, ansv);
|
||||
ans = max(ans, Ru + Rv - 1);
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int ks = 0;
|
||||
scanf("%d", &T);
|
||||
bool ok = 0;
|
||||
while (T--)
|
||||
{
|
||||
if (ok != 0)
|
||||
{
|
||||
puts("");
|
||||
}
|
||||
ok = 1;
|
||||
printf("Case #%d:\n", ++ks);
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
init();
|
||||
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
|
||||
for (int i = 2; i <= n; i++)
|
||||
{
|
||||
int s;
|
||||
scanf("%d", &s);
|
||||
add(s, i);
|
||||
}
|
||||
dfs(1, -1, 1);
|
||||
process(n);
|
||||
int Q;
|
||||
scanf("%d", &Q);
|
||||
while (Q--)
|
||||
{
|
||||
int u, v;
|
||||
scanf("%d %d", &u, &v);
|
||||
printf("%d\n", getans(u, v));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
o o o o o o o o o o o o o o o o o o
|
||||
/F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\
|
||||
/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#define lson step << 1
|
||||
#define rson step << 1 | 1
|
||||
#define lowbit(x) (x & (-x))
|
||||
#define Key_value ch[ch[root][1]][0]
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 505;
|
||||
int n , m , r , q;
|
||||
int food[N][N] , prod[N][N];
|
||||
int a[N * N] , b[N * N] , tot , x[N * N];
|
||||
int s[N * N] , cnt;
|
||||
void add (int x , int v) {
|
||||
for (int i = x ; i <= cnt ; i += lowbit (i)) {
|
||||
s[i] = max (s[i] , v);
|
||||
}
|
||||
}
|
||||
int ask (int x) {
|
||||
int ret = 0;
|
||||
for (int i = x ; i > 0 ; i -= lowbit (i)) {
|
||||
ret = max (ret , s[i]);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main () {
|
||||
int t , cas = 0;
|
||||
scanf ("%d" , &t);
|
||||
while (t --) {
|
||||
memset (food , 0 , sizeof(food));
|
||||
memset (prod , 0 , sizeof(prod));
|
||||
memset (s , 0 , sizeof(s));
|
||||
scanf ("%d %d %d %d" , &n , &m , &r , &q);
|
||||
for (int i = 1 ; i <= n ; i ++) {
|
||||
for (int j = 1 ; j <= m ; j ++) {
|
||||
scanf ("%d" , &food[i][j]);
|
||||
food[i][j] += food[i - 1][j] + food[i][j - 1] - food[i - 1][j - 1];
|
||||
}
|
||||
}
|
||||
for (int i = 1 ; i <= n ; i ++) {
|
||||
for (int j = 1 ; j <= m ; j ++) {
|
||||
scanf ("%d" , &prod[i][j]);
|
||||
prod[i][j] += prod[i - 1][j] + prod[i][j - 1] - prod[i - 1][j - 1];
|
||||
}
|
||||
}
|
||||
tot = 0;
|
||||
r = 2 * r + 1;
|
||||
for (int i = r ; i <= n ; i ++) {
|
||||
for (int j = r ; j <= m ; j ++) {
|
||||
a[tot] = food[i][j] - food[i][j - r] - food[i - r][j] + food[i - r][j - r];
|
||||
b[tot] = prod[i][j] - prod[i][j - r] - prod[i - r][j] + prod[i - r][j - r];
|
||||
x[tot] = a[tot];
|
||||
tot ++;
|
||||
}
|
||||
}
|
||||
sort (x , x + tot);
|
||||
cnt = unique (x , x + tot) - x;
|
||||
for (int i = 0 ; i < tot ; i ++) {
|
||||
int y = cnt - (lower_bound (x , x + cnt , a[i]) - x);
|
||||
add (y , b[i]);
|
||||
}
|
||||
printf ("Case #%d:\n" , ++ cas);
|
||||
while (q --) {
|
||||
int A , B;
|
||||
scanf ("%d %d" , &A , &B);
|
||||
int low = min (A , B) + r * r * 1 , high = min (A , B) + r * r * 3 , mid , ans;
|
||||
while (low <= high) {
|
||||
mid = (low + high) >> 1;
|
||||
int y = cnt - (lower_bound (x , x + cnt , mid - A) - x);
|
||||
if (y < 1) {
|
||||
high = mid - 1;
|
||||
continue;
|
||||
}
|
||||
int tmp = ask (y);
|
||||
if (tmp + B >= mid) {
|
||||
ans = mid;
|
||||
low = mid + 1;
|
||||
}
|
||||
else high = mid - 1;
|
||||
}
|
||||
printf ("%d\n" , ans);
|
||||
}
|
||||
if (t) puts ("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
__int64 bit[20];
|
||||
__int64 dp[20][10];
|
||||
__int64 solve(__int64 n)
|
||||
{
|
||||
__int64 ans;
|
||||
__int64 tem1 = n,len,sum,i,x,j,k;
|
||||
len = sum = ans = 0;
|
||||
memset(dp,0,sizeof(dp));
|
||||
while(tem1)
|
||||
{
|
||||
bit[++len] = tem1%10;
|
||||
tem1/=10;
|
||||
}
|
||||
for(i = 1; i<=len/2; i++)
|
||||
{
|
||||
int t;
|
||||
t = bit[i];
|
||||
bit[i] = bit[len-i+1];
|
||||
bit[len-i+1] = t;
|
||||
}
|
||||
x = 0;
|
||||
for(i = 1; i<=len; i++)
|
||||
{
|
||||
for(j = 0; j<10; j++)
|
||||
for(k = 0; k<10; k++)
|
||||
dp[i][(j+k)%10]+=dp[i-1][j];
|
||||
for(j = 0; j<bit[i]; j++)
|
||||
dp[i][(x+j)%10]++;
|
||||
x = (x+bit[i])%10;
|
||||
}
|
||||
if(!x)
|
||||
dp[len][0]++;
|
||||
return dp[len][0];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
__int64 T,l,r,cas = 1;
|
||||
__int64 ans;
|
||||
scanf("%I64d",&T);
|
||||
while(T--)
|
||||
{
|
||||
ans = 0;
|
||||
scanf("%I64d%I64d",&l,&r);
|
||||
ans = solve(r)-solve(l-1);
|
||||
printf("Case #%I64d: %I64d\n",cas++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include <stdio.h>
|
||||
#include <cmath>
|
||||
#define maxn 100010
|
||||
double a[maxn],b[maxn],up,down,ans,g;
|
||||
int n,m,x,y;
|
||||
int main(){
|
||||
int i,j,k,t,cas=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
ans=0;
|
||||
scanf("%lf%lf",&up,&down);
|
||||
g=(up-down)*(up-down);
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%lf",&a[i]);
|
||||
for(i=0;i<m;i++)
|
||||
scanf("%lf",&b[i]);
|
||||
x=0,y=0;
|
||||
while(x<n && y < m){
|
||||
ans+=sqrt(g+(a[x]-b[y])*(a[x]-b[y]));
|
||||
if(x==n-1) y++;
|
||||
else if(y==m-1) x++;
|
||||
else{
|
||||
if(fabs(a[x]-b[y+1]) < fabs(b[y]-a[x+1]))
|
||||
y++;
|
||||
else x++;
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %.2lf\n",++cas,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
g++ a.o b.o -o main
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int INF=0x3f3f3f3f;
|
||||
const int MAXN=1000010;
|
||||
struct qnode
|
||||
{
|
||||
int v;
|
||||
int c;
|
||||
qnode(int _v=0,int _c=0):v(_v),c(_c){}
|
||||
bool operator <(const qnode &r)const
|
||||
{
|
||||
return c>r.c;
|
||||
}
|
||||
};
|
||||
struct Edge
|
||||
{
|
||||
int v,cost;
|
||||
Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
|
||||
};
|
||||
vector<Edge>E[MAXN];
|
||||
bool vis[MAXN];
|
||||
int dist[MAXN];
|
||||
void Dijkstra(int n,int start)
|
||||
{
|
||||
memset(vis,false,sizeof(vis));
|
||||
for(int i=1;i<=n;i++)dist[i]=INF;
|
||||
priority_queue<qnode>que;
|
||||
while(!que.empty())que.pop();
|
||||
dist[start]=0;
|
||||
que.push(qnode(start,0));
|
||||
qnode tmp;
|
||||
while(!que.empty())
|
||||
{
|
||||
tmp=que.top();
|
||||
que.pop();
|
||||
int u=tmp.v;
|
||||
if(vis[u])continue;
|
||||
vis[u]=true;
|
||||
for(int i=0;i<E[u].size();i++)
|
||||
{
|
||||
int v=E[tmp.v][i].v;
|
||||
int cost=E[u][i].cost;
|
||||
if(!vis[v]&&dist[v]>dist[u]+cost)
|
||||
{
|
||||
dist[v]=dist[u]+cost;
|
||||
que.push(qnode(v,dist[v]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void addedge(int u,int v,int w)
|
||||
{
|
||||
E[u].push_back(Edge(v,w));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int N,M,C;
|
||||
scanf("%d",&T);
|
||||
int iCase = 0;
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d",&N,&M,&C);
|
||||
for(int i = 1;i <= 3*N;i++) E[i].clear();
|
||||
int u,v,w;
|
||||
for(int i = 1;i <= N;i++)
|
||||
{
|
||||
scanf("%d",&u);
|
||||
addedge(i,N + 2*u - 1,0);
|
||||
addedge(N + 2*u ,i,0);
|
||||
}
|
||||
for(int i = 1;i < N;i++)
|
||||
{
|
||||
addedge(N + 2*i-1,N + 2*(i+1),C);
|
||||
addedge(N + 2*(i+1)-1,N + 2*i,C);
|
||||
}
|
||||
while(M--)
|
||||
{
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
addedge(u,v,w);
|
||||
addedge(v,u,w);
|
||||
}
|
||||
Dijkstra(3*N,1);
|
||||
iCase++;
|
||||
if(dist[N] == INF)dist[N] = -1;
|
||||
printf("Case #%d: %d\n",iCase,dist[N]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
int a[20];
|
||||
int b[20];
|
||||
char A[2000020],B[2000020];
|
||||
int num1[2000020],num2[2000020];
|
||||
int ans[2000020];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int iCase = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%s%s",A,B);
|
||||
int n = strlen(A);
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
num1[i] = A[i] - '0';
|
||||
num2[i] = B[i] - '0';
|
||||
}
|
||||
if(n == 1)
|
||||
{
|
||||
printf("Case #%d: %d\n",iCase,(num1[0]+num2[0])%10);
|
||||
continue;
|
||||
}
|
||||
memset(a,0,sizeof(a));
|
||||
memset(b,0,sizeof(b));
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
a[num1[i]] ++;
|
||||
b[num2[i]] ++;
|
||||
}
|
||||
int x = 0, y = 0;
|
||||
int ttt = -1;
|
||||
for(int i = 1;i <= 9;i++)
|
||||
for(int j = 1;j <= 9;j++)
|
||||
if(a[i] && b[j] && ((i+j)%10) > ttt )
|
||||
{
|
||||
x = i;
|
||||
y = j;
|
||||
ttt = (x+y)%10;
|
||||
}
|
||||
a[x]--;
|
||||
b[y]--;
|
||||
int cnt = 0;
|
||||
ans[cnt++] = (x+y)%10;
|
||||
for(int p = 9;p >= 0;p--)
|
||||
{
|
||||
for(int i = 0;i <= 9;i++)
|
||||
if(a[i])
|
||||
{
|
||||
if(i <= p)
|
||||
{
|
||||
int j = p-i;
|
||||
int k = min(a[i],b[j]);
|
||||
a[i] -= k;
|
||||
b[j] -= k;
|
||||
while(k--)
|
||||
ans[cnt++] = p;
|
||||
}
|
||||
int j = 10 + p - i;
|
||||
if(j > 9)continue;
|
||||
int k = min(a[i],b[j]);
|
||||
a[i] -= k;
|
||||
b[j] -= k;
|
||||
while(k--)
|
||||
ans[cnt++] = p;
|
||||
}
|
||||
}
|
||||
printf("Case #%d: ",iCase);
|
||||
int s = 0;
|
||||
while(s < cnt-1 && ans[s] == 0)s++;
|
||||
for(int i = s;i < cnt;i++)
|
||||
printf("%d",ans[i]);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
int a[100010];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
scanf("%d",&T);
|
||||
int iCase = 0;
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d",&n);
|
||||
for(int i = 0;i < n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
int ans = 1;
|
||||
for(int i = 1;i < n;i++)
|
||||
if(a[i] != a[i-1] + 1)
|
||||
{
|
||||
ans = i+1;
|
||||
break;
|
||||
}
|
||||
printf("Case #%d: %d\n",iCase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
int main() {
|
||||
char a[120];
|
||||
int t, tt = 0;
|
||||
scanf("%d", &t);
|
||||
while(t--) {
|
||||
scanf("%s", a);
|
||||
printf("Case #%d: ", ++tt);
|
||||
int len = strlen(a);
|
||||
if(a[len-1] == 'u' && a[len-2] == 's' && a[len-3] == 'e' && a[len-4] == 'd' &&
|
||||
a[len-5] == 'o' && a[len-6] == 'n' && a[len-7] == 'a' && a[len-8] == 'n') {
|
||||
printf("%s", a);
|
||||
}
|
||||
else if(a[len-1] == 'u' && a[len-2] == 's' && a[len-3] == 'e' && a[len-4] == 'd') {
|
||||
for(int i=0; i<len-4; i++) {
|
||||
printf("%c", a[i]);
|
||||
}
|
||||
printf("nanodesu\n");
|
||||
}
|
||||
else {
|
||||
printf("%s", a);
|
||||
printf("nanodesu\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
char str[10000];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int m,n;
|
||||
int iCase = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&m,&n);
|
||||
iCase++;
|
||||
printf("Case #%d: ",iCase);
|
||||
if(m == 1)
|
||||
{
|
||||
for(int i = 0;i < n;i++)printf("a");
|
||||
printf("\n");
|
||||
continue;
|
||||
}
|
||||
if(m >= 3)
|
||||
{
|
||||
int index = 0;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
printf("%c",index + 'a');
|
||||
index = (index + 1)%3;
|
||||
}
|
||||
printf("\n");
|
||||
continue;
|
||||
}
|
||||
if(n == 1)printf("a");
|
||||
else if(n == 2)printf("ab");
|
||||
else if(n == 3)printf("aab");
|
||||
else if(n == 4)printf("aabb");
|
||||
else if(n == 5)printf("aaaba");
|
||||
else if(n == 6)printf("aaabab");
|
||||
else if(n == 7)printf("aaababb");
|
||||
else if(n == 8)printf("aaababbb");
|
||||
else if(n == 9)printf("aaaababba");
|
||||
else
|
||||
{
|
||||
printf("aaaa");
|
||||
n -= 4;
|
||||
while(n >= 6)
|
||||
{
|
||||
printf("babbaa");
|
||||
n -= 6;
|
||||
}
|
||||
if(n == 1)printf("a");
|
||||
else if(n == 2)printf("aa");
|
||||
else if(n == 3)printf("bab");
|
||||
else if(n == 4)printf("babb");
|
||||
else if(n == 5)printf("babba");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int,int> PII;
|
||||
#define MP make_pair
|
||||
#define PB push_back
|
||||
#define AA first
|
||||
#define BB second
|
||||
#define OP begin()
|
||||
#define ED end()
|
||||
#define SZ size()
|
||||
#define cmin(x,y) x=min(x,y)
|
||||
#define cmax(x,y) x=max(x,y)
|
||||
const LL MOD = 1000000007;
|
||||
const int MXN = 200005;
|
||||
int mu[MXN], p[MXN], pn;
|
||||
bool flag[MXN];
|
||||
void init(int n=MXN-5) {
|
||||
pn = 0;
|
||||
mu[1] = 1;
|
||||
for(int i = 2; i <= n; i++) {
|
||||
if(!flag[i]) {
|
||||
p[pn ++ ] = i;
|
||||
mu[i] = -1;
|
||||
}
|
||||
for(int j = 0; j < pn && i * p[j] <= n; j++) {
|
||||
flag[i * p [j]] = true;
|
||||
if(i % p[j] == 0) {
|
||||
mu[i * p[j]] = 0;
|
||||
break;
|
||||
} else mu[i * p[j]] = -mu[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
LL inv[200005];
|
||||
LL fact[200005];
|
||||
LL ifac[200005];
|
||||
LL comb(LL a,LL b){
|
||||
return fact[a]*ifac[b]%MOD*ifac[a-b]%MOD;
|
||||
}
|
||||
LL play(int n,int m){
|
||||
return comb(n+m-1,n-1);
|
||||
}
|
||||
int N,M,K,n;
|
||||
LL solve(int n,int M){
|
||||
LL ans=0;
|
||||
for(int i=0;i<=n&&i*K<=M;i++){
|
||||
LL mul=comb(n,i);
|
||||
LL add=play(n,M-i*K);
|
||||
if(i&1)ans-=mul*add%MOD;
|
||||
else ans+=mul*add%MOD;
|
||||
}
|
||||
return ans%MOD;
|
||||
}
|
||||
LL g(int x){
|
||||
int d=n/x;
|
||||
if(M%d)return 0;
|
||||
return solve(x,M/d);
|
||||
}
|
||||
LL gao(int x){
|
||||
int y=x;
|
||||
vector<int>L;
|
||||
for(int i=2;i*i<=x;i++)if(x%i==0){
|
||||
L.PB(i);
|
||||
while(x%i==0)x/=i;
|
||||
}
|
||||
if(x>1)L.PB(x);
|
||||
x=y;
|
||||
LL ret=0;
|
||||
for(int i=0;i<1<<L.SZ;i++){
|
||||
int d=1,mu=1;
|
||||
for(int j=0;j<L.SZ;j++)if(i>>j&1)
|
||||
d*=L[j],mu=-mu;
|
||||
ret+=mu*inv[d];
|
||||
}
|
||||
return ret%MOD;
|
||||
}
|
||||
int main(){
|
||||
init();
|
||||
int i,j,_T;
|
||||
for(inv[0]=inv[1]=1,i=2;i<=200001;i++)
|
||||
inv[i]=inv[MOD%i]*(MOD-MOD/i)%MOD;
|
||||
for(fact[0]=i=1;i<=200001;i++)
|
||||
fact[i]=fact[i-1]*i%MOD;
|
||||
for(ifac[0]=i=1;i<=200001;i++)
|
||||
ifac[i]=ifac[i-1]*inv[i]%MOD;
|
||||
scanf("%d",&_T);
|
||||
for(int CA=1;CA<=_T;CA++){
|
||||
scanf("%d%d%d",&N,&M,&K);
|
||||
printf("Case #%d: ",CA);
|
||||
n=N-M;
|
||||
if(n==0)printf("%d\n",N>=K?0:1);
|
||||
else {
|
||||
int gg=__gcd(n,M);
|
||||
set<int>SD;
|
||||
for(i=1;i*i<=gg;i++)if(gg%i==0)
|
||||
SD.insert(i),SD.insert(gg/i);
|
||||
vector<int>D(SD.OP,SD.ED);
|
||||
LL ans=0;
|
||||
map<int,LL>W;
|
||||
for(i=0;i<D.SZ;i++){
|
||||
int u=D[i],v=n/u;
|
||||
for(int w=1;w*w<=v;w++)if(v%w==0){
|
||||
int d=w;
|
||||
W[d]+=inv[v]*mu[v/d];
|
||||
if(w*w!=v){
|
||||
d=v/w;
|
||||
W[d]+=inv[v]*mu[v/d];
|
||||
}
|
||||
}
|
||||
}
|
||||
for(map<int,LL>::iterator it=W.OP;it!=W.ED;++it)
|
||||
ans+=(*it).BB%MOD*g((*it).AA);
|
||||
ans=(ans%MOD+MOD)%MOD;
|
||||
printf("%d\n",int(ans));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,149 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<bitset>
|
||||
#define inf 0x3f3f3f3f
|
||||
#define Inf 0x3FFFFFFFFFFFFFFFLL
|
||||
#define eps 1e-6
|
||||
#define pi acos(-1.0)
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn=100000+10;
|
||||
const int mod=1000000000+7;
|
||||
char A[maxn],B[maxn];
|
||||
int n,lsts[maxn][2],zero[maxn];
|
||||
ll dp[maxn][2];
|
||||
bool check(int i)
|
||||
{
|
||||
return (i+1>n)||(A[i+1]!='0'&&B[i+1]!='0'&&zero[i+2]);
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
lsts[0][0]=dp[0][0]=1;
|
||||
lsts[0][1]=dp[0][1]=0;
|
||||
for(int i=1;i<=n;++i)
|
||||
{
|
||||
if(A[i]=='?'&&B[i]=='?')
|
||||
{
|
||||
dp[i][0]=(dp[i-1][0]+dp[i-1][1])%mod;
|
||||
dp[i][1]=(dp[i-1][0]+dp[i-1][1])%mod;
|
||||
lsts[i][0]=lsts[i-1][0]+lsts[i-1][1];
|
||||
lsts[i][1]=lsts[i-1][0]+lsts[i-1][1];
|
||||
if(lsts[i][0]>2) lsts[i][0]=2;
|
||||
if(lsts[i][1]>2) lsts[i][1]=2;
|
||||
}
|
||||
else if(A[i]=='?'||B[i]=='?'||(A[i]==B[i]))
|
||||
{
|
||||
if(A[i]=='0'||B[i]=='0')
|
||||
{
|
||||
dp[i][0]=dp[i-1][0];
|
||||
dp[i][1]=dp[i-1][1];
|
||||
lsts[i][0]=lsts[i-1][0];
|
||||
lsts[i][1]=lsts[i-1][1];
|
||||
}
|
||||
else
|
||||
{
|
||||
dp[i][0]=dp[i-1][1];
|
||||
dp[i][1]=dp[i-1][0];
|
||||
lsts[i][0]=lsts[i-1][1];
|
||||
lsts[i][1]=lsts[i-1][0];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
dp[i][0]=dp[i][1]=0;
|
||||
lsts[i][0]=lsts[i][1]=0;
|
||||
}
|
||||
}
|
||||
zero[n+1]=1;
|
||||
for(int i=n;i>=1;--i)
|
||||
{
|
||||
if(A[i]=='1'||B[i]=='1')
|
||||
zero[i]=0;
|
||||
else zero[i]=zero[i+1];
|
||||
}
|
||||
ll sum=0,tmp;
|
||||
int dt=0,pos=-1,dtmp;
|
||||
for(int i=1;i<=n;++i)
|
||||
{
|
||||
if(A[i]=='?'&&B[i]=='?')
|
||||
{
|
||||
tmp=(dp[i-1][0]+dp[i-1][1])%mod;
|
||||
dtmp=lsts[i-1][0]+lsts[i-1][1];
|
||||
if(dtmp&&check(i))
|
||||
{
|
||||
pos=i;
|
||||
sum=(sum+tmp)%mod;
|
||||
dt+=dtmp;
|
||||
if(dt>2) dt=2;
|
||||
}
|
||||
}
|
||||
else if(A[i]=='?'||B[i]=='?'||(A[i]!=B[i]))
|
||||
{
|
||||
if(A[i]=='0'||B[i]=='1')
|
||||
{
|
||||
tmp=dp[i-1][0];
|
||||
dtmp=lsts[i-1][0];
|
||||
}
|
||||
else
|
||||
{
|
||||
tmp=dp[i-1][1];
|
||||
dtmp=lsts[i-1][1];
|
||||
}
|
||||
if(dtmp&&check(i))
|
||||
{
|
||||
pos=i;
|
||||
sum=(sum+tmp)%mod;
|
||||
dt+=dtmp;
|
||||
if(dt>2) dt=2;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(dt==0) printf("Impossible\n");
|
||||
else if(dt>1) printf("Ambiguous %I64d\n",sum);
|
||||
else
|
||||
{
|
||||
for(int i=pos+1;i<=n;++i)
|
||||
A[i]='1',B[i]='0';
|
||||
char ch,last;
|
||||
if(A[pos]=='0'||B[pos]=='1') ch='0';
|
||||
else ch='1';
|
||||
A[pos]='0';B[pos]='1';
|
||||
for(int i=pos-1;i>=1;--i)
|
||||
{
|
||||
last=ch;
|
||||
if(A[i]=='1'||B[i]=='1') ch=(ch=='0')?'1':'0';
|
||||
A[i]=B[i]=last;
|
||||
}
|
||||
for(int i=n;i>1;--i)
|
||||
{
|
||||
if(A[i-1]==A[i]) A[i]='0';
|
||||
else A[i]='1';
|
||||
if(B[i-1]==B[i]) B[i]='0';
|
||||
else B[i]='1';
|
||||
}
|
||||
printf("%s\n",A+1);
|
||||
printf("%s\n",B+1);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,tcase=0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%s",A+1);
|
||||
scanf("%s",B+1);
|
||||
n=strlen(A+1);
|
||||
printf("Case #%d:\n",++tcase);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int dp[10][200000], mx[10];
|
||||
int dfs(int len, int pre, bool flag)
|
||||
{
|
||||
if (len < 0) return pre >= 0;
|
||||
if (pre < 0) return 0;
|
||||
if (!flag && dp[len][pre] != -1) return dp[len][pre];
|
||||
int end = flag?mx[len]:9, ans = 0;
|
||||
for (int i = 0; i <= end; ++i) {
|
||||
ans += dfs(len-1, pre-i*(1<<len), flag&&i==end);
|
||||
}
|
||||
if (!flag) dp[len][pre] = ans;
|
||||
return ans;
|
||||
}
|
||||
int f(int x)
|
||||
{
|
||||
int tmp = 1, ans = 0;
|
||||
while (x) {
|
||||
ans += x%10*tmp;
|
||||
x /= 10;
|
||||
tmp *= 2;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int cal(int a, int b)
|
||||
{
|
||||
int top = 0;
|
||||
while (b) {
|
||||
mx[top++] = b%10;
|
||||
b /= 10;
|
||||
}
|
||||
return dfs(top-1, f(a), true);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int iCase = 1, nCase;
|
||||
int a, b;
|
||||
scanf("%d", &nCase);
|
||||
memset(dp, 0xff, sizeof(dp));
|
||||
while (nCase--) {
|
||||
scanf("%d %d", &a, &b);
|
||||
printf("Case #%d: %d\n", iCase++, cal(a, b));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,224 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#define inf 0x3f3f3f
|
||||
using namespace std;
|
||||
const int maxn=60;
|
||||
const int maxr=maxn*maxn+maxn;
|
||||
int n,D;
|
||||
int child[maxn];
|
||||
int boys;
|
||||
bool flag;
|
||||
int map[maxn][maxn];
|
||||
void init_m()
|
||||
{
|
||||
for(int i=0;i<=n;i++)
|
||||
for(int j=0;j<=n;j++)
|
||||
{
|
||||
if(i==j)
|
||||
{
|
||||
map[i][j]=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
map[i][j]=inf;
|
||||
}
|
||||
}
|
||||
}
|
||||
void floyd()
|
||||
{
|
||||
for(int k=1;k<=n;k++)
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
if(map[i][k]+map[k][j]<map[i][j])
|
||||
{
|
||||
map[i][j]=map[i][k]+map[k][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
struct node
|
||||
{
|
||||
int l,r;
|
||||
int u,d;
|
||||
int s,c;
|
||||
};
|
||||
node dlx[maxr];
|
||||
int h[maxn];
|
||||
int limit;
|
||||
int Q[maxn];
|
||||
int X[maxr];
|
||||
int has[maxn];
|
||||
int head,size;
|
||||
void init(int r,int c)
|
||||
{
|
||||
head=0;
|
||||
for(int i=0; i<=c; i++)
|
||||
{
|
||||
dlx[i].s=0;
|
||||
dlx[i].u=dlx[i].d=i;
|
||||
dlx[i].r=i+1;
|
||||
dlx[i+1].l=i;
|
||||
}
|
||||
size=c;
|
||||
dlx[c].r=0;
|
||||
while(r)
|
||||
{
|
||||
h[r--]=-1;
|
||||
}
|
||||
}
|
||||
void link(int r,int c)
|
||||
{
|
||||
int tmp=++size;
|
||||
dlx[c].s++;
|
||||
dlx[tmp].c=c;
|
||||
X[tmp]=r;
|
||||
dlx[tmp].d=dlx[c].d;
|
||||
dlx[tmp].u=c;
|
||||
dlx[dlx[c].d].u=tmp;
|
||||
dlx[c].d=tmp;
|
||||
if(h[r]<0)
|
||||
{
|
||||
h[r]=dlx[tmp].l=dlx[tmp].r=tmp;
|
||||
}
|
||||
else
|
||||
{
|
||||
dlx[tmp].r=dlx[h[r]].r;
|
||||
dlx[tmp].l=h[r];
|
||||
dlx[dlx[h[r]].r].l=tmp;
|
||||
dlx[h[r]].r=tmp;
|
||||
}
|
||||
}
|
||||
void remove(int x)
|
||||
{
|
||||
for(int i=dlx[x].d; i!=x; i=dlx[i].d)
|
||||
{
|
||||
dlx[dlx[i].r].l=dlx[i].l;
|
||||
dlx[dlx[i].l].r=dlx[i].r;
|
||||
dlx[dlx[i].c].s--;
|
||||
}
|
||||
}
|
||||
void resume(int x)
|
||||
{
|
||||
for(int i=dlx[x].u; i!=x; i=dlx[i].u)
|
||||
{
|
||||
dlx[dlx[i].r].l=i;
|
||||
dlx[dlx[i].l].r=i;
|
||||
dlx[dlx[i].c].s++;
|
||||
}
|
||||
}
|
||||
int hh()
|
||||
{
|
||||
int ret=0;
|
||||
memset(has,0,sizeof(has));
|
||||
for(int i=dlx[head].r; i!=head; i=dlx[i].r)
|
||||
{
|
||||
if(has[i]==false)
|
||||
{
|
||||
has[i]=true;
|
||||
ret++;
|
||||
for(int j=dlx[i].d; j!=i; j=dlx[j].d)
|
||||
for(int k=dlx[j].r; k!=j; k=dlx[k].r)
|
||||
{
|
||||
has[dlx[k].c]=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void dlx_dfs(int k)
|
||||
{
|
||||
if(k+hh()>boys)
|
||||
{
|
||||
return;
|
||||
}
|
||||
int ssd=0;
|
||||
for(int i=0;i<k;i++)
|
||||
{
|
||||
ssd+=child[Q[i]];
|
||||
}
|
||||
if(k-ssd>=limit) return;
|
||||
if(dlx[head].r==head)
|
||||
{
|
||||
flag=true;
|
||||
limit=k-ssd;
|
||||
return;
|
||||
}
|
||||
int minn=n+2;
|
||||
int tt;
|
||||
for(int i=dlx[head].r; i!=head; i=dlx[i].r)
|
||||
{
|
||||
if(minn>dlx[i].s)
|
||||
{
|
||||
minn=dlx[i].s;
|
||||
tt=i;
|
||||
}
|
||||
}
|
||||
for(int i=dlx[tt].d; i!=tt; i=dlx[i].d)
|
||||
{
|
||||
Q[k]=X[i];
|
||||
remove(i);
|
||||
for(int j=dlx[i].r; j!=i; j=dlx[j].r)
|
||||
{
|
||||
remove(j);
|
||||
}
|
||||
dlx_dfs(k+1);
|
||||
for(int j=dlx[i].l; j!=i; j=dlx[j].l)
|
||||
{
|
||||
resume(j);
|
||||
}
|
||||
resume(i);
|
||||
}
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
int cas=1;
|
||||
while(t--)
|
||||
{
|
||||
printf("Case #%d: ",cas++);
|
||||
scanf("%d%d",&n,&D);
|
||||
boys=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&child[i]);
|
||||
if(child[i]==1)
|
||||
{
|
||||
boys++;
|
||||
}
|
||||
}
|
||||
init_m();
|
||||
int a,b,c;
|
||||
for(int i=0;i<n-1;i++)
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
map[a][b]=c;
|
||||
map[b][a]=c;
|
||||
}
|
||||
floyd();
|
||||
init(n,n);
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
if(map[i][j]<=D)
|
||||
{
|
||||
link(i,j);
|
||||
}
|
||||
}
|
||||
flag=false;
|
||||
limit=inf;
|
||||
dlx_dfs(0);
|
||||
if(!flag)
|
||||
{
|
||||
printf("-1\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("%d\n",limit);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
- Kenneth Snow, The Hollow Bear
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int MAXN = 100010;
|
||||
int a[MAXN];
|
||||
int num[40];
|
||||
int bit[40];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n,m;
|
||||
bit[0] = 1;
|
||||
for(int i = 1;i <= 31;i++)
|
||||
bit[i] = 2*bit[i-1];
|
||||
scanf("%d",&T);
|
||||
int iCase = 0;
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i = 0;i < n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
long long tot = (long long)n*(n+1)/2;
|
||||
int last = 0;
|
||||
int i = 0,j = 0;
|
||||
memset(num,0,sizeof(num));
|
||||
long long sum = 0;
|
||||
while(j < n)
|
||||
{
|
||||
for(int k = 0;k <=31;k++)
|
||||
if(a[j] & bit[k])
|
||||
num[k]++;
|
||||
int s = 0;
|
||||
for(int k = 0;k <= 31;k++)
|
||||
if(num[k])
|
||||
s += bit[k];
|
||||
if(s >= m)
|
||||
{
|
||||
while(s >=m)
|
||||
{
|
||||
for(int k = 0;k <= 31;k++)
|
||||
if(a[i] & bit[k])
|
||||
num[k]--;
|
||||
s = 0;
|
||||
for(int k = 0;k <= 31;k++)
|
||||
if(num[k])
|
||||
s += bit[k];
|
||||
i++;
|
||||
}
|
||||
sum += (long long)(n-j)*(i-last);
|
||||
last = i;
|
||||
}
|
||||
j++;
|
||||
}
|
||||
printf("Case #%d: ",iCase);
|
||||
cout<<tot-sum<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAXN = 1010;
|
||||
struct Edge
|
||||
{
|
||||
int to;
|
||||
int next;
|
||||
int w;
|
||||
}edge[MAXN*MAXN];
|
||||
int tot;
|
||||
int head[MAXN];
|
||||
void add(int s, int u, int w)
|
||||
{
|
||||
edge[tot].to = u;
|
||||
edge[tot].w = w;
|
||||
edge[tot].next = head[s];
|
||||
head[s] = tot++;
|
||||
edge[tot].to = s;
|
||||
edge[tot].w = w;
|
||||
edge[tot].next = head[u];
|
||||
head[u] = tot++;
|
||||
}
|
||||
int n, m;
|
||||
int dfn[MAXN], low[MAXN], sta[MAXN], col[MAXN];
|
||||
int tt, sum, scc, top;
|
||||
void tarjan(int u, int fa)
|
||||
{
|
||||
dfn[u] = low[u] = ++tt;
|
||||
sta[++top] = u;
|
||||
int cnt=0;
|
||||
for(int i = head[u]; i; i = edge[i].next) {
|
||||
int v = edge[i].to;
|
||||
if(!dfn[v]) {
|
||||
sum++;
|
||||
tarjan(v, u);
|
||||
low[u] = min(low[u], low[v]);
|
||||
} else if (fa == v) {
|
||||
if (cnt) low[u] = min(low[u],dfn[v]);
|
||||
cnt++;
|
||||
} else low[u] = min(low[u],dfn[v]);
|
||||
}
|
||||
if(dfn[u]==low[u]) {
|
||||
int x;
|
||||
scc++;
|
||||
do {
|
||||
x = sta[top--];
|
||||
col[x] = scc;
|
||||
} while(x != u);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int a, b, w;
|
||||
int ans;
|
||||
while (scanf("%d %d", &n, &m)) {
|
||||
if (n == 0 && m == 0) break;
|
||||
memset(dfn, 0, sizeof(dfn));
|
||||
memset(low, 0, sizeof(low));
|
||||
memset(col, 0, sizeof(col));
|
||||
memset(head, 0, sizeof(head));
|
||||
tot = sum = 1;
|
||||
tt = scc = top = 0;
|
||||
ans = 10010;
|
||||
while (m--) {
|
||||
scanf("%d %d %d", &a, &b, &w);
|
||||
add(a, b, w);
|
||||
}
|
||||
tarjan(1, 1);
|
||||
if (sum < n) puts("0");
|
||||
else {
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
for (int j = head[i]; j; j = edge[j].next) {
|
||||
int v = edge[j].to;
|
||||
if (col[i] != col[v]) ans = min(ans, edge[j].w);
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans?(ans == 10010?-1:ans):1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
struct Point{
|
||||
int x,y;
|
||||
}point[22];
|
||||
int dp[(1<<20)+2];
|
||||
int n;
|
||||
int cmp(const Point &p,const Point &q)
|
||||
{
|
||||
if(p.y==q.y){
|
||||
return p.x<q.x;
|
||||
}
|
||||
return p.y<q.y;
|
||||
}
|
||||
bool Judge(int i,int j,int k,int l)
|
||||
{
|
||||
if(point[i].x==point[j].x&&point[i].y==point[j].y)return false;
|
||||
if(point[i].y!=point[j].y||point[i].x!=point[k].x||point[j].x!=point[l].x||point[k].y!=point[l].y)
|
||||
return false;
|
||||
if(abs(point[i].x-point[j].x)!=abs(point[i].y-point[k].y))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
vector<int>g[22];
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n)){
|
||||
if(n==-1)break;
|
||||
for(int i=0;i<n;i++)scanf("%d%d",&point[i].x,&point[i].y);
|
||||
sort(point,point+n,cmp);
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(int i=0;i<=n;i++)g[i].clear();
|
||||
for(int i=0;i<n;i++){
|
||||
for(int j=i+1;j<n;j++){
|
||||
for(int k=j+1;k<n;k++){
|
||||
for(int l=k+1;l<n;l++){
|
||||
if(Judge(i,j,k,l)){
|
||||
int state=0;
|
||||
state|=(1<<i);
|
||||
state|=(1<<j);
|
||||
state|=(1<<k);
|
||||
state|=(1<<l);
|
||||
g[i].push_back(state);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int state=0;state<(1<<n);state++){
|
||||
for(int i=0;i<n;i++){
|
||||
if(state&(1<<i)){
|
||||
for(int j=0;j<g[i].size();j++){
|
||||
int S=g[i][j];
|
||||
if((S|state)==state)dp[state]=max(dp[state],dp[state^S]+4);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",dp[(1<<n)-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
#define MAXN 1005
|
||||
int dir[4][2] = { {0,1}, {1,0}, {0,-1}, {-1,0} } ;
|
||||
int n, flag, p, q ;
|
||||
int donkey[MAXN][MAXN], tiger[MAXN][MAXN] ;
|
||||
void DFS(int a, int b, int c, int x, int y, int z) {
|
||||
donkey[a][b] = 1;
|
||||
tiger[x][y] = 1;
|
||||
if(flag) return ;
|
||||
if(a == x && b == y) {
|
||||
flag = 1;
|
||||
printf("%d %d\n", a, b);
|
||||
return ;
|
||||
}
|
||||
if(p && q) {
|
||||
flag = 1;
|
||||
printf("-1\n");
|
||||
return ;
|
||||
}
|
||||
int aa, bb, xx, yy;
|
||||
if(p) {
|
||||
aa = a;
|
||||
bb = b;
|
||||
}
|
||||
else {
|
||||
aa = a + dir[c][0];
|
||||
bb = b + dir[c][1];
|
||||
if(aa < 0 || bb < 0 || aa >= n || bb >= n || donkey[aa][bb] == 1) {
|
||||
c = (c+1)%4;
|
||||
aa = a + dir[c][0];
|
||||
bb = b + dir[c][1];
|
||||
if(aa < 0 || bb < 0 || aa >= n || bb >= n || donkey[aa][bb] == 1) {
|
||||
p = 1;
|
||||
aa = a;
|
||||
bb = b;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(q) {
|
||||
xx = x;
|
||||
yy = y;
|
||||
}
|
||||
else {
|
||||
xx = x + dir[z][0];
|
||||
yy = y + dir[z][1];
|
||||
if(xx < 0 || yy < 0 || xx >= n || yy >= n || tiger[xx][yy] == 1) {
|
||||
z = (z-1+4)%4;
|
||||
xx = x + dir[z][0];
|
||||
yy = y + dir[z][1];
|
||||
if(xx < 0 || yy < 0 || xx >= n || yy >= n || tiger[xx][yy] == 1) {
|
||||
q = 1;
|
||||
xx = x;
|
||||
yy = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
DFS(aa, bb, c, xx, yy, z);
|
||||
}
|
||||
int main() {
|
||||
int a, b, c, x, y, z ;
|
||||
while(scanf("%d", &n), n) {
|
||||
scanf("%d%d%d", &a, &b, &c);
|
||||
scanf("%d%d%d", &x, &y, &z);
|
||||
if(a == x && b == y) {
|
||||
printf("%d %d\n", a, b);
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
memset(donkey, 0, sizeof(donkey));
|
||||
memset(tiger, 0, sizeof(tiger ));
|
||||
flag = p = q = 0;
|
||||
DFS(a, b, c, x, y, z);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct point
|
||||
{
|
||||
double x,y,z;
|
||||
point(double _x,double _y,double _z)
|
||||
{
|
||||
x=_x;y=_y;z=_z;
|
||||
}
|
||||
};
|
||||
struct Vector
|
||||
{
|
||||
double x,y,z;
|
||||
Vector(double _x,double _y,double _z)
|
||||
{
|
||||
x=_x,y=_y,z=_z;
|
||||
}
|
||||
};
|
||||
struct plane
|
||||
{
|
||||
double a,b,c,d;
|
||||
plane(double _a,double _b,double _c,double _d)
|
||||
{
|
||||
a=_a,b=_b,c=_c,d=_d;
|
||||
}
|
||||
};
|
||||
Vector getvector(point a,point b)
|
||||
{
|
||||
Vector ans=Vector(a.x-b.x,a.y-b.y,a.z-b.z);
|
||||
return ans;
|
||||
}
|
||||
Vector Common_Vertical_Line(Vector a,Vector b)
|
||||
{
|
||||
Vector ans=Vector(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
|
||||
return ans;
|
||||
}
|
||||
double pointDis(Vector a)
|
||||
{
|
||||
return sqrt((a.x*a.x+a.y*a.y+a.z*a.z));
|
||||
}
|
||||
plane getPlane(Vector a,Vector b,point c)
|
||||
{
|
||||
Vector line=Common_Vertical_Line(a,b);
|
||||
plane ans=plane(line.x,line.y,line.z,line.x*(-1)*c.x+line.y*(-1)*c.y+line.z*(-1)*c.z);
|
||||
return ans;
|
||||
}
|
||||
point getPoint(plane P,Vector B,point C)
|
||||
{
|
||||
double k=((-1)*P.b*C.y-P.a*C.x-P.c*C.z-P.d)/(P.a*B.x+P.b*B.y+P.c*B.z);
|
||||
point ans=point(B.x*k+C.x,B.y*k+C.y,B.z*k+C.z);
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
double a,b,c;
|
||||
scanf("%lf%lf%lf",&a,&b,&c);point x1=point(a,b,c);
|
||||
scanf("%lf%lf%lf",&a,&b,&c);point y1=point(a,b,c);
|
||||
scanf("%lf%lf%lf",&a,&b,&c);point x2=point(a,b,c);
|
||||
scanf("%lf%lf%lf",&a,&b,&c);point y2=point(a,b,c);
|
||||
Vector l1=getvector(x1,y1);
|
||||
Vector l2=getvector(x2,y2);
|
||||
Vector line=Common_Vertical_Line(l1,l2);
|
||||
plane p1=getPlane(l1,line,x1);
|
||||
plane p2=getPlane(l2,line,x2);
|
||||
point ans2=getPoint(p1,l2,x2);
|
||||
point ans1=getPoint(p2,l1,x1);
|
||||
Vector ans=getvector(ans1,ans2);
|
||||
printf("%.6lf\n",pointDis(ans));
|
||||
printf("%.6lf %.6lf %.6lf %.6lf %.6lf %.6lf\n",ans1.x,ans1.y,ans1.z,ans2.x,ans2.y,ans2.z);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#define lowbit(x) (x & (-x))
|
||||
#define mp(a,b) make_pair (a , b)
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 100005;
|
||||
typedef pair<int , int> pii;
|
||||
struct Node {
|
||||
int x , y , z , id;
|
||||
void input () {
|
||||
scanf ("%d %d %d" , &x , &y, &z);
|
||||
}
|
||||
bool operator < (const Node &n) const {
|
||||
return x != n.x ? x < n.x : (y != n.y ? y < n.y : z < n.z);
|
||||
}
|
||||
}a[N] , b[N];
|
||||
int x[N] , m , n;
|
||||
pii dp[N] , bit[N];
|
||||
void update (pii &a , pii b) {
|
||||
if (b.first > a.first) a = b;
|
||||
else if (b.first == a.first) a.second += b.second;
|
||||
}
|
||||
void init () {
|
||||
for (int i = 1 ; i <= m ; i ++)
|
||||
bit[i] = mp(0 , 0);
|
||||
}
|
||||
void add (int idx , pii val) {
|
||||
for (int i = idx ; i <= m ; i += lowbit (i))
|
||||
update (bit[i] , val);
|
||||
}
|
||||
pii ask (int idx) {
|
||||
pii ans = mp (0 , 0);
|
||||
for (int i = idx ; i > 0 ; i -= lowbit (i))
|
||||
update (ans , bit[i]);
|
||||
return ans;
|
||||
}
|
||||
void clear (int idx) {
|
||||
for (int i = idx ; i <= m ; i += lowbit (i))
|
||||
bit[i] = mp (0 , 0);
|
||||
}
|
||||
void gao (int l , int r) {
|
||||
if (l == r) return ;
|
||||
int mid = (l + r) >> 1;
|
||||
gao (l , mid);
|
||||
int cnt = 0;
|
||||
for (int i = l ; i <= r ; i ++) {
|
||||
b[cnt ++] = a[i];
|
||||
b[cnt - 1].x = 0;
|
||||
}
|
||||
sort (b , b + cnt);
|
||||
for (int i = 0 ; i < cnt ; i ++) {
|
||||
if (b[i].id <= mid) {
|
||||
add (b[i].z , dp[b[i].id]);
|
||||
}
|
||||
else {
|
||||
pii t = ask (b[i].z);
|
||||
t.first ++;
|
||||
update (dp[b[i].id] , t);
|
||||
}
|
||||
}
|
||||
for (int i = 0 ; i < cnt ; i ++)
|
||||
if (b[i].id <= mid)
|
||||
clear (b[i].z);
|
||||
gao (mid + 1 , r);
|
||||
}
|
||||
int main () {
|
||||
int t ;
|
||||
scanf ("%d" , &t);
|
||||
while (t --) {
|
||||
scanf ("%d" , &n);
|
||||
for (int i = 0 ; i < n ; i ++) {
|
||||
a[i].input ();
|
||||
x[i] = a[i].z;
|
||||
dp[i] = mp (1 , 1);
|
||||
}
|
||||
sort (x , x + n);
|
||||
m = unique (x , x + n) - x;
|
||||
for (int i = 0 ; i < n ; i ++)
|
||||
a[i].z = lower_bound (x , x + m , a[i].z) - x + 1;
|
||||
sort (a , a + n);
|
||||
for (int i = 0 ; i < n ; i ++)
|
||||
a[i].id = i;
|
||||
init ();
|
||||
gao (0 , n - 1);
|
||||
pii ans = mp (0 , 0);
|
||||
for (int i = 0 ; i < n ; i ++) {
|
||||
update (ans , dp[i]);
|
||||
}
|
||||
printf ("%d %d\n" , ans.first , ans.second);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
#include <cstdio>
|
||||
#include <queue>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int MAXN = 210;
|
||||
const int MAXE = 210 * 210 * 2;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
struct ZKW_flow{
|
||||
int st, ed, ecnt, n;
|
||||
int head[MAXN];
|
||||
int cap[MAXE], cost[MAXE], to[MAXE], next[MAXE];
|
||||
void init(){
|
||||
memset(head, 0, sizeof(head));
|
||||
ecnt = 2;
|
||||
}
|
||||
void addEdge(int u, int v, int cc, int ww){
|
||||
cap[ecnt] = cc; cost[ecnt] = ww; to[ecnt] = v;
|
||||
next[ecnt] = head[u]; head[u] = ecnt++;
|
||||
cap[ecnt] = 0; cost[ecnt] = -ww; to[ecnt] = u;
|
||||
next[ecnt] = head[v]; head[v] = ecnt++;
|
||||
}
|
||||
int dis[MAXN];
|
||||
void SPFA(){
|
||||
for(int i = 1; i <= n; ++i) dis[i] = INF;
|
||||
priority_queue<pair<int, int> > Q;
|
||||
dis[st] = 0;
|
||||
Q.push(make_pair(0, st));
|
||||
while(!Q.empty()){
|
||||
int u = Q.top().second, d = -Q.top().first;
|
||||
Q.pop();
|
||||
if(dis[u] != d) continue;
|
||||
for(int p = head[u]; p; p = next[p]){
|
||||
int &v = to[p];
|
||||
if(cap[p] && dis[v] > d + cost[p]){
|
||||
dis[v] = d + cost[p];
|
||||
Q.push(make_pair(-dis[v], v));
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i = 1; i <= n; ++i) dis[i] = dis[ed] - dis[i];
|
||||
}
|
||||
int minCost, maxFlow;
|
||||
bool use[MAXN];
|
||||
int add_flow(int u, int flow){
|
||||
if(u == ed){
|
||||
maxFlow += flow;
|
||||
minCost += dis[st] * flow;
|
||||
return flow;
|
||||
}
|
||||
use[u] = true;
|
||||
int now = flow;
|
||||
for(int p = head[u]; p; p = next[p]){
|
||||
int &v = to[p];
|
||||
if(cap[p] && !use[v] && dis[u] == dis[v] + cost[p]){
|
||||
int tmp = add_flow(v, min(now, cap[p]));
|
||||
cap[p] -= tmp;
|
||||
cap[p^1] += tmp;
|
||||
now -= tmp;
|
||||
if(!now) break;
|
||||
}
|
||||
}
|
||||
return flow - now;
|
||||
}
|
||||
bool modify_label(){
|
||||
int d = INF;
|
||||
for(int u = 1; u <= n; ++u) if(use[u])
|
||||
for(int p = head[u]; p; p = next[p]){
|
||||
int &v = to[p];
|
||||
if(cap[p] && !use[v]) d = min(d, dis[v] + cost[p] - dis[u]);
|
||||
}
|
||||
if(d == INF) return false;
|
||||
for(int i = 1; i <= n; ++i) if(use[i]) dis[i] += d;
|
||||
return true;
|
||||
}
|
||||
int min_cost_flow(int ss, int tt, int nn){
|
||||
st = ss, ed = tt, n = nn;
|
||||
minCost = maxFlow = 0;
|
||||
SPFA();
|
||||
while(true){
|
||||
while(true){
|
||||
for(int i = 1; i <= n; ++i) use[i] = 0;
|
||||
if(!add_flow(st, INF)) break;
|
||||
}
|
||||
if(!modify_label()) break;
|
||||
}
|
||||
return minCost;
|
||||
}
|
||||
} G;
|
||||
struct Point {
|
||||
int x, y, z, w;
|
||||
void read() {
|
||||
scanf("%d%d%d%d", &x, &y, &z, &w);
|
||||
}
|
||||
int operator * (const Point &rhs) const {
|
||||
double xx = x - rhs.x, yy = y - rhs.y, zz = z - rhs.z;
|
||||
return (int)sqrt(xx * xx + yy * yy + zz * zz);
|
||||
}
|
||||
};
|
||||
Point a[MAXN];
|
||||
int n;
|
||||
int main() {
|
||||
while(scanf("%d", &n) != EOF && n) {
|
||||
int sumw = 0;
|
||||
for(int i = 1; i <= n; ++i) a[i].read(), sumw += a[i].w;
|
||||
G.init();
|
||||
int ss = 2 * n + 1, tt = ss + 1;
|
||||
for(int i = 1; i <= n; ++i) {
|
||||
G.addEdge(ss, i, a[i].w, 0);
|
||||
G.addEdge(i + n, tt, a[i].w, 0);
|
||||
for(int j = i + 1; j <= n; ++j) {
|
||||
int cost = a[i] * a[j];
|
||||
G.addEdge(i, j + n, INF, cost);
|
||||
G.addEdge(j, i + n, INF, cost);
|
||||
}
|
||||
}
|
||||
int ans = G.min_cost_flow(ss, tt, tt);
|
||||
if(sumw != G.maxFlow) ans = -1;
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
int s[1005];
|
||||
int dp[1005][1005];
|
||||
int max(int a,int b)
|
||||
{
|
||||
return a>b?a:b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while (cin>>n&&n)
|
||||
{
|
||||
memset(dp,0,sizeof(dp));
|
||||
for (int i=1;i<=n;i++)
|
||||
cin>>s[i];
|
||||
for (int l=1;l<=n;l++)
|
||||
{
|
||||
for (int i=1;i+l-1<=n;i++)
|
||||
{
|
||||
int j=i+l-1;
|
||||
int p=2;
|
||||
if (i==j)
|
||||
p=1;
|
||||
if (s[j]==s[i])
|
||||
dp[i][j]=p+dp[i+1][j-1];
|
||||
else
|
||||
dp[i][j]=max(dp[i][j-1],dp[i+1][j]);
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for (int i=0;i<=n;i++)
|
||||
ans=max(ans,dp[1][i]+dp[i+1][n]);
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define LL long long
|
||||
#define M 500005
|
||||
#define N 19
|
||||
int cal(int n, int x)
|
||||
{
|
||||
int res = 0;
|
||||
do
|
||||
{
|
||||
++res;
|
||||
n /= x;
|
||||
}
|
||||
while (n % x == 0);
|
||||
return res;
|
||||
}
|
||||
int F[M][N];
|
||||
int num[M];
|
||||
int h[M];
|
||||
int mob(int n)
|
||||
{
|
||||
if (h[n] == -1) return 0;
|
||||
if (h[n] & 1) return -1;
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t, n, m, p, i, j;
|
||||
for (i = 2; i < M; i++)
|
||||
{
|
||||
if (num[i]) continue;
|
||||
for (j = i; j < M; j+=i)
|
||||
{
|
||||
int tp = cal(j, i);
|
||||
num[j] += tp;
|
||||
if (tp > 1)
|
||||
{
|
||||
h[j] = -1;
|
||||
}
|
||||
else if (h[j] >= 0)
|
||||
{
|
||||
++h[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 1; i < M; i++)
|
||||
{
|
||||
for (j = i; j < M; j+=i)
|
||||
{
|
||||
F[j][num[i]] += mob(j/i);
|
||||
}
|
||||
}
|
||||
for (i = 1; i < M; i++)
|
||||
{
|
||||
for (j = 1; j < N; j++)
|
||||
{
|
||||
F[i][j] += F[i][j-1];
|
||||
}
|
||||
}
|
||||
for (i = 1; i < M; i++)
|
||||
{
|
||||
for (j = 0; j < N; j++)
|
||||
{
|
||||
F[i][j] += F[i-1][j];
|
||||
}
|
||||
}
|
||||
scanf("%d", &t);
|
||||
while (t--)
|
||||
{
|
||||
scanf("%d%d%d", &n, &m, &p);
|
||||
LL ans = 0;
|
||||
if (p >= N)
|
||||
{
|
||||
ans = (LL)n*m;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (n > m)
|
||||
{
|
||||
n ^= m;
|
||||
m ^= n;
|
||||
n ^= m;
|
||||
}
|
||||
for (i = 1; i <= n; i = j + 1)
|
||||
{
|
||||
j = min(n/(n/i), m/(m/i));
|
||||
ans += ((LL)F[j][p]-F[i-1][p])*(n/i)*(m/i);
|
||||
}
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int MAXN = 200010;
|
||||
struct Node
|
||||
{
|
||||
int l,r;
|
||||
long long sum;
|
||||
int mx;
|
||||
int lazy;
|
||||
}segTree[MAXN*3];
|
||||
void push_up(int i)
|
||||
{
|
||||
if(segTree[i].l == segTree[i].r)return;
|
||||
segTree[i].sum = segTree[i<<1].sum + segTree[(i<<1)|1].sum;
|
||||
segTree[i].mx = max(segTree[i<<1].mx,segTree[(i<<1)|1].mx);
|
||||
}
|
||||
void Update_Same(int i,int v)
|
||||
{
|
||||
segTree[i].sum = (long long)v*(segTree[i].r - segTree[i].l + 1);
|
||||
segTree[i].mx = v;
|
||||
segTree[i].lazy = 1;
|
||||
}
|
||||
void push_down(int i)
|
||||
{
|
||||
if(segTree[i].l == segTree[i].r)return;
|
||||
if(segTree[i].lazy)
|
||||
{
|
||||
Update_Same(i<<1,segTree[i].mx);
|
||||
Update_Same((i<<1)|1,segTree[i].mx);
|
||||
segTree[i].lazy = 0;
|
||||
}
|
||||
}
|
||||
int mex[MAXN];
|
||||
void Build(int i,int l,int r)
|
||||
{
|
||||
segTree[i].l = l;
|
||||
segTree[i].r = r;
|
||||
segTree[i].lazy = 0;
|
||||
if(l == r)
|
||||
{
|
||||
segTree[i].mx = mex[l];
|
||||
segTree[i].sum = mex[l];
|
||||
return;
|
||||
}
|
||||
int mid = (l + r)>>1;
|
||||
Build(i<<1,l,mid);
|
||||
Build((i<<1)|1,mid+1,r);
|
||||
push_up(i);
|
||||
}
|
||||
void Update(int i,int l,int r,int v)
|
||||
{
|
||||
if(segTree[i].l == l && segTree[i].r == r)
|
||||
{
|
||||
Update_Same(i,v);
|
||||
return;
|
||||
}
|
||||
push_down(i);
|
||||
int mid = (segTree[i].l + segTree[i].r)>>1;
|
||||
if(r <= mid)
|
||||
{
|
||||
Update(i<<1,l,r,v);
|
||||
}
|
||||
else if(l > mid)
|
||||
{
|
||||
Update((i<<1)|1,l,r,v);
|
||||
}
|
||||
else
|
||||
{
|
||||
Update(i<<1,l,mid,v);
|
||||
Update((i<<1)|1,mid+1,r,v);
|
||||
}
|
||||
push_up(i);
|
||||
}
|
||||
int Get(int i,int v)
|
||||
{
|
||||
if(segTree[i].l == segTree[i].r)
|
||||
return segTree[i].l;
|
||||
push_down(i);
|
||||
if(segTree[i<<1].mx > v)
|
||||
return Get(i<<1,v);
|
||||
else return Get((i<<1)|1,v);
|
||||
}
|
||||
int a[MAXN];
|
||||
map<int,int>mp;
|
||||
int ne[MAXN];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n) && n)
|
||||
{
|
||||
for(int i = 1;i <= n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
mp.clear();
|
||||
int tmp = 0;
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
mp[a[i]] = 1;
|
||||
while(mp.find(tmp) != mp.end())tmp++;
|
||||
mex[i] = tmp;
|
||||
}
|
||||
mp.clear();
|
||||
for(int i = n;i >= 1;i--)
|
||||
{
|
||||
if(mp.find(a[i]) == mp.end())ne[i] = n+1;
|
||||
else ne[i] = mp[a[i]];
|
||||
mp[a[i]] = i;
|
||||
}
|
||||
Build(1,1,n);
|
||||
long long sum = 0;
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
sum += segTree[1].sum;
|
||||
if(segTree[1].mx > a[i])
|
||||
{
|
||||
int l = Get(1,a[i]);
|
||||
int r = ne[i];
|
||||
if(l < r)
|
||||
Update(1,l,r-1,a[i]);
|
||||
}
|
||||
Update(1,i,i,0);
|
||||
}
|
||||
printf("%I64d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define INF 1000000000
|
||||
#define MAXN 100005
|
||||
int vis[30];
|
||||
int ne[MAXN];
|
||||
int s[MAXN],p[MAXN];
|
||||
int c1[30][MAXN],c2[30][MAXN];
|
||||
int cal_s(int pos,int k)
|
||||
{
|
||||
if(pos<0) return 0;
|
||||
int s=0;
|
||||
for(int i=1;i<k;i++) s+=c1[i][pos];
|
||||
return s;
|
||||
}
|
||||
int cal_p(int pos,int k)
|
||||
{
|
||||
if(pos<0) return 0;
|
||||
int s=0;
|
||||
for(int i=1;i<k;i++) s+=c2[i][pos];
|
||||
return s;
|
||||
}
|
||||
bool isok(int i,int j)
|
||||
{
|
||||
if(!j) return true;
|
||||
if (c2[p[j]][j]!=c1[s[i]][i]-c1[s[i]][i-j-1]) return false;
|
||||
int cnt1=cal_s(i,s[i]);
|
||||
int cnt2=cal_s(i-j-1,s[i]);
|
||||
int cnt3=cal_p(j,p[j]);
|
||||
return cnt1-cnt2==cnt3;
|
||||
}
|
||||
bool ok(int i,int j)
|
||||
{
|
||||
if(!j) return true;
|
||||
if (c2[p[j]][j]!=c2[p[i]][i]-c2[p[i]][i-j-1]) return false;
|
||||
int cnt1=cal_p(i,p[i]);
|
||||
int cnt2=cal_p(i-j-1,p[i]);
|
||||
int cnt3=cal_p(j,p[j]);
|
||||
return cnt1-cnt2==cnt3;
|
||||
}
|
||||
void getnext(int n)
|
||||
{
|
||||
bool flag;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
int j=ne[i];
|
||||
flag=ok(i,j);
|
||||
while(j&&!flag)
|
||||
{
|
||||
j=ne[j];
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
ne[i+1]=j+1;
|
||||
}
|
||||
else
|
||||
{
|
||||
ne[i+1]=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans;
|
||||
int kmp(int n,int m)
|
||||
{
|
||||
getnext(m);
|
||||
bool flag;
|
||||
int j=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
flag=isok(i,j);
|
||||
while(j&&!flag) {j=ne[j];flag=isok(i,j);}
|
||||
if(flag) j++;
|
||||
if(j==m)
|
||||
{
|
||||
ans++;
|
||||
j=0;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
inline int ReadInt()
|
||||
{
|
||||
int flag=0;
|
||||
char ch = getchar();
|
||||
int data = 0;
|
||||
while (ch < '0' || ch > '9')
|
||||
{
|
||||
if(ch=='-') flag=1;
|
||||
ch = getchar();
|
||||
}
|
||||
do
|
||||
{
|
||||
data = data*10 + ch-'0';
|
||||
ch = getchar();
|
||||
}while (ch >= '0' && ch <= '9');
|
||||
if(flag) data=-data;
|
||||
return data;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,kk;
|
||||
while(~scanf("%d%d%d",&n,&m,&kk))
|
||||
{
|
||||
ans=0;
|
||||
memset(c1,0,sizeof(c1));
|
||||
memset(c2,0,sizeof(c2));
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
s[i]=ReadInt();
|
||||
if(i){
|
||||
for(int j=1;j<=kk;j++){
|
||||
c1[j][i]=c1[j][i-1];}
|
||||
}
|
||||
c1[s[i]][i]++;
|
||||
}
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
p[i]=ReadInt();
|
||||
if(i)
|
||||
for(int j=1;j<=kk;j++)
|
||||
c2[j][i]=c2[j][i-1];
|
||||
c2[p[i]][i]++;
|
||||
}
|
||||
getnext(m);
|
||||
kmp(n,m);
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <iomanip>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <memory.h>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <ctype.h>
|
||||
#define INF 1000000010
|
||||
#define ll long long
|
||||
#define max3(a,b,c) max(a,max(b,c))
|
||||
#define MAXN 100010
|
||||
using namespace std;
|
||||
struct edge{
|
||||
int u;
|
||||
int v;
|
||||
int w;
|
||||
};
|
||||
edge E[500010];
|
||||
bool cmp(edge e1,edge e2){
|
||||
return e1.w<e2.w;
|
||||
}
|
||||
int p[10010];
|
||||
int find(int x){
|
||||
if(x!=p[x])p[x]=find(p[x]);
|
||||
return p[x];
|
||||
}
|
||||
int setsize[10010];
|
||||
void _union(int a,int b){
|
||||
int fa=find(a);
|
||||
int fb=find(b);
|
||||
p[fa]=fb;
|
||||
setsize[fb]+=setsize[fa];
|
||||
}
|
||||
map<ll,int> mp;
|
||||
int cnt[500010];
|
||||
int num[500010];
|
||||
int ans[10010];
|
||||
int main(){
|
||||
int n,m;
|
||||
while(cin>>n>>m){
|
||||
for(int i=0;i<n;i++)p[i]=i;
|
||||
for(int i=0;i<n;i++)setsize[i]=1;
|
||||
memset(cnt,0,sizeof(cnt));
|
||||
memset(num,0,sizeof(num));
|
||||
mp.clear();
|
||||
for(int i=1;i<=m;i++){
|
||||
int a,b,c;
|
||||
scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].w);
|
||||
}
|
||||
sort(E+1,E+m+1,cmp);
|
||||
for(int i=1;i<=m;i++){
|
||||
int u=E[i].u;
|
||||
int v=E[i].v;
|
||||
int fu=find(u);
|
||||
int fv=find(v);
|
||||
int su=setsize[fu];
|
||||
int sv=setsize[fv];
|
||||
if(fu!=fv){
|
||||
mp[E[i].w]+=su*sv*2;
|
||||
_union(u,v);
|
||||
}
|
||||
}
|
||||
int q=1;
|
||||
for(map<ll,int>::iterator it=mp.begin();it!=mp.end();it++){
|
||||
num[q]=it->first;
|
||||
cnt[q]=it->second;
|
||||
q++;
|
||||
}
|
||||
int size=mp.size();
|
||||
num[size+1]=INF;
|
||||
for(int i=size;i>=0;i--){
|
||||
cnt[i]+=cnt[i+1];
|
||||
}
|
||||
int p;
|
||||
cin>>p;
|
||||
for(int k=0;k<p;k++){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
int l=0;
|
||||
int r=size+1;
|
||||
while(true){
|
||||
int mid=(r+l)/2;
|
||||
if(num[mid]==t){
|
||||
printf("%d\n",cnt[mid]);
|
||||
break;
|
||||
}
|
||||
if(num[mid]>t){
|
||||
r=mid;
|
||||
}else{
|
||||
if(num[mid+1]>t){
|
||||
printf("%d\n",cnt[mid+1]);
|
||||
break;
|
||||
}
|
||||
l=mid;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int MAXN = 110;
|
||||
int color[MAXN];
|
||||
int head[MAXN];
|
||||
struct Edge
|
||||
{
|
||||
int to,next;
|
||||
}edge[MAXN*MAXN];
|
||||
int tot;
|
||||
void addedge(int u,int v)
|
||||
{
|
||||
edge[tot].to = v;
|
||||
edge[tot].next = head[u];
|
||||
head[u] = tot++;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
tot = 0;
|
||||
memset(head,-1,sizeof(head));
|
||||
}
|
||||
bool dfs(int u,int col)
|
||||
{
|
||||
color[u] = col;
|
||||
for(int i = head[u];i != -1;i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].to;
|
||||
if(color[v] != -1)
|
||||
{
|
||||
if(color[v]==col)return false;
|
||||
continue;
|
||||
}
|
||||
if(!dfs(v,!col))return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int g[MAXN][MAXN];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n) == 1)
|
||||
{
|
||||
memset(g,0,sizeof(g));
|
||||
int t;
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
while(scanf("%d",&t) && t)
|
||||
{
|
||||
g[i][t] = 1;
|
||||
}
|
||||
}
|
||||
init();
|
||||
for(int i = 1;i <= n;i++)
|
||||
for(int j = i+1;j <= n;j++)
|
||||
if(g[i][j] == 0 || g[j][i] == 0)
|
||||
{
|
||||
addedge(i,j);
|
||||
addedge(j,i);
|
||||
}
|
||||
memset(color,-1,sizeof(color));
|
||||
bool flag = true;
|
||||
for(int i = 1;i <= n;i++)
|
||||
if(color[i] == -1 && dfs(i,0) == false)
|
||||
{
|
||||
flag = false;
|
||||
break;
|
||||
}
|
||||
if(flag)printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#include <climits>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <list>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <deque>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 20005;
|
||||
const double eps = 1e-8;
|
||||
int n, a, b, c, l, r;
|
||||
int x[maxn], y[maxn];
|
||||
double p[maxn*2];
|
||||
int tot;
|
||||
int dcmp(double x) {if (fabs(x) < eps) return 0; return x > 0 ? 1 : -1;}
|
||||
double func(double x)
|
||||
{
|
||||
return (a * x + b) * x + c;
|
||||
}
|
||||
bool between(double a, double b, double c) {return dcmp(a - b) > 0 && dcmp(c - a) > 0;}
|
||||
bool solve(double a, double b, double c, double &x1, double &x2)
|
||||
{
|
||||
double d = b*b - 4*a*c;
|
||||
if (dcmp(d) <= 0) return 0;
|
||||
d = sqrt(d);
|
||||
x1 = (-b - d) / a * 0.5;
|
||||
x2 = (-b + d) / a * 0.5;
|
||||
return 1;
|
||||
}
|
||||
void get(int x1, int y1, int x2, int y2)
|
||||
{
|
||||
if (x1 == x2)
|
||||
{
|
||||
double y = func(x1);
|
||||
if (y1 > y2) swap(y1, y2);
|
||||
if (between(y, y1, y2)) p[tot++] = x1;
|
||||
}
|
||||
else
|
||||
{
|
||||
double k = (double)(y2 - y1) / (x2 - x1), r1, r2;
|
||||
if (solve(a, b - k, c + k * x1 - y1, r1, r2))
|
||||
{
|
||||
if (x1 > x2) swap(x1, x2);
|
||||
if (between(r1, x1, x2)) p[tot++] = r1;
|
||||
if (between(r2, x1, x2)) p[tot++] = r2;
|
||||
}
|
||||
}
|
||||
}
|
||||
double sqr(double x) {return x * x;}
|
||||
double f(double x)
|
||||
{
|
||||
return sqrt(sqr(2*a*x + b) + 1);
|
||||
}
|
||||
double simpson(double p1, double p2)
|
||||
{
|
||||
double mid = (p1 + p2) / 2, mid1 = (p1 + mid) / 2, mid2 = (mid + p2) / 2;
|
||||
double f1 = f(p1), f2 = f(p2), fm = f(mid), fm1 = f(mid1), fm2 = f(mid2);
|
||||
double tmp = (f1 + fm * 4 + f2) * (p2 - p1) / 6;
|
||||
if (dcmp(tmp - (f1 + fm1 * 4 + fm) * (mid - p1) / 6 - (fm + fm2 * 4 + f2) * (p2 - mid) / 6) == 0) return tmp;
|
||||
return simpson(p1, mid) + simpson(mid, p2);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int nr;
|
||||
double r1, r2;
|
||||
while (scanf("%d", &n) == 1)
|
||||
{
|
||||
scanf("%d%d%d%d%d", &a, &b, &c, &l, &r);
|
||||
for (int i=0;i<n;i++) scanf("%d%d", &x[i], &y[i]);
|
||||
x[n] = x[0]; y[n] = y[0]; x[n+1] = x[1]; y[n+1] = y[1];
|
||||
tot = 0;
|
||||
for (int i=0;i<n;i++) get(x[i], y[i], x[i+1], y[i+1]);
|
||||
for (int i=1;i<=n;i++)
|
||||
{
|
||||
double x1 = (x[i-1] - x[i]) * 1e-3 + x[i], y1 = (y[i-1] - y[i]) * 1e-3 + y[i];
|
||||
double x2 = (x[i+1] - x[i]) * 1e-3 + x[i], y2 = (y[i+1] - y[i]) * 1e-3 + y[i];
|
||||
if (dcmp(func(x1) - y1) * dcmp(func(x2) - y2) < 0) p[tot++] = x[i];
|
||||
}
|
||||
sort(p, p+tot);
|
||||
double ans = 0;
|
||||
tot--;
|
||||
for (int i=0;i<tot;i++)
|
||||
if (!(i&1)) ans += simpson(max((double)l, p[i]), min((double)r, p[i+1]));
|
||||
printf("%.2lf\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
int dp[10001];
|
||||
int visit[10001];
|
||||
int vis[25];
|
||||
int oth[25];
|
||||
int ts;
|
||||
int num(int vist[])
|
||||
{
|
||||
int i;
|
||||
int sum=0;
|
||||
for(i=1;i<=9;i++)
|
||||
{
|
||||
if(vist[i]&&vist[i+3]&&vist[i+12+(i-1)/3]&&vist[i+13+(i-1)/3])sum++;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int dos(int x)
|
||||
{
|
||||
int sum=0,i;
|
||||
int vist[26];
|
||||
for(i=0;i<=24;i++)vist[i]=0;
|
||||
for(i=1;i<=ts;i++)
|
||||
{
|
||||
if(x&(1<<(i-1)))
|
||||
{
|
||||
vist[oth[i-1]]=1;
|
||||
}
|
||||
}
|
||||
for(i=1;i<=24;i++)
|
||||
{
|
||||
if(vis[i])vist[i]=1;
|
||||
}
|
||||
sum=num(vist);
|
||||
return sum;
|
||||
}
|
||||
int dfs(int x)
|
||||
{
|
||||
if(visit[x]!=-1)return visit[x];
|
||||
int ans=0;
|
||||
for(int i=1;i<=ts;i++)
|
||||
{
|
||||
if(!(x&(1<<(i-1))))
|
||||
{
|
||||
int y;
|
||||
y=x+(1<<(i-1));
|
||||
int ss;
|
||||
ss=dfs(y);
|
||||
ans=max(9-dp[x]-ss,ans);
|
||||
}
|
||||
}
|
||||
visit[x]=ans;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,i,n,a,b;
|
||||
int cas;
|
||||
int anum,bnum,s;
|
||||
cas=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
cas++;
|
||||
anum=bnum=0;
|
||||
s=0;
|
||||
scanf("%d",&n);
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(visit,-1,sizeof(visit));
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
if(a>b)swap(a,b);
|
||||
if(b-a==4)ts=12+a;
|
||||
else ts=a-a/4;
|
||||
vis[ts]=1;
|
||||
if(i%2==0)
|
||||
{
|
||||
anum+=num(vis)-s;
|
||||
}
|
||||
else bnum+=num(vis)-s;
|
||||
s=num(vis);
|
||||
}
|
||||
ts=0;
|
||||
for(i=1;i<=24;i++)if(vis[i]==0)oth[ts++]=i;
|
||||
for(i=0;i<(1<<ts);i++)dp[i]=dos(i);
|
||||
int have;
|
||||
have=9-s;
|
||||
int fs;
|
||||
fs=dfs(0);
|
||||
printf("Case #%d: ",cas);
|
||||
if(n%2==0)
|
||||
{
|
||||
if(anum+fs>bnum+have-fs)cout<<"Tom200"<<endl;
|
||||
else cout<<"Jerry404"<<endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(anum+have-fs>bnum+fs)cout<<"Tom200"<<endl;
|
||||
else cout<<"Jerry404"<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
const int maxn = 1015;
|
||||
const int maxm = maxn*maxn;
|
||||
const int inf1 = 0x3f3f3f3f;
|
||||
const double inf2 = 9999999999;
|
||||
struct Point {
|
||||
double x,y;
|
||||
}pnt[ maxn ];
|
||||
struct Edge{
|
||||
int u,v;
|
||||
double val;
|
||||
int id;
|
||||
}edge[ maxn<<1 ];
|
||||
int cnt_edge;
|
||||
double mat[ maxn ][ maxn ];
|
||||
double dis[ maxn ];
|
||||
bool vis[ maxn ];
|
||||
int pre[ maxn ];
|
||||
double LenPrim1;
|
||||
double LenPrim2;
|
||||
int fa[ maxn ],ran[ maxn ];
|
||||
int find( int x ){
|
||||
if( x==fa[x] ) return x;
|
||||
else return fa[ x ] = find( fa[x] );
|
||||
}
|
||||
void init( int n ){
|
||||
for( int i=0;i<n;i++ ){
|
||||
fa[ i ] = i;
|
||||
ran[ i ] = 1;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
double dist( int i,int j ){
|
||||
return sqrt( (pnt[i].x-pnt[j].x)*(pnt[i].x-pnt[j].x)+(pnt[i].y-pnt[j].y)*(pnt[i].y-pnt[j].y) );
|
||||
}
|
||||
int cmp( Edge a,Edge b ){
|
||||
return a.val<b.val;
|
||||
}
|
||||
void GetMap( int n ){
|
||||
for( int i=0;i<n;i++ )
|
||||
for( int j=0;j<n;j++ ){
|
||||
mat[i][j] = dist( i,j );
|
||||
}
|
||||
return ;
|
||||
}
|
||||
double prim( int n,int Belong ){
|
||||
for( int i=0;i<n;i++ ){
|
||||
dis[ i ] = mat[0][i];
|
||||
vis[ i ] = false;
|
||||
pre[ i ] = 0;
|
||||
}
|
||||
vis[0] = true;
|
||||
double ans = 0;
|
||||
for( int i=0;i<n;i++ ){
|
||||
int id = -1;
|
||||
double M = inf2;
|
||||
for( int j=0;j<n;j++ ){
|
||||
if( !vis[j] && M>dis[j] ){
|
||||
M = dis[j];
|
||||
id = j;
|
||||
}
|
||||
}
|
||||
if( id==-1 ) break;
|
||||
vis[ id ] = true;
|
||||
ans += M;
|
||||
edge[ cnt_ ].u = pre[ id ];
|
||||
edge[ cnt_ ].v = id;
|
||||
edge[ cnt_ ].id = Belong;
|
||||
edge[ cnt_ ].val = mat[ id ][ pre[id] ];
|
||||
cnt_edge ++ ;
|
||||
for( int j=0;j<n;j++ ){
|
||||
if( !vis[j] && dis[j]>mat[id][j] ){
|
||||
dis[j] = mat[id][j];
|
||||
pre[ j ] = id;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void Deal( int n ){
|
||||
for( int i=0;i<cnt_edge;i++ ){
|
||||
mat[ edge[i].u ][ edge[i].v ] = inf2;
|
||||
mat[ edge[i].v ][ edge[i].u ] = inf2;
|
||||
}
|
||||
}
|
||||
double Kruskal( int n,int id ){
|
||||
double ans = 0;
|
||||
init( n );
|
||||
int cnt = 0;
|
||||
for( int i=0;i<cnt_edge;i++ ){
|
||||
if( i==id ) continue;
|
||||
int fx = find( edge[i].u );
|
||||
int fy = find( edge[i].v );
|
||||
if( fx!=fy ){
|
||||
if( ran[ fx ]<ran[ fy ] ){
|
||||
ran[ fy ] += ran[ fx ];
|
||||
fa[ fx ] = fy;
|
||||
}
|
||||
else {
|
||||
ran[ fx ] += ran[ fy ];
|
||||
fa[ fy ] = fx;
|
||||
}
|
||||
cnt ++ ;
|
||||
ans += edge[i].val;
|
||||
if( cnt==n-1 ) break;
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main(){
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while( T-- ){
|
||||
int n;
|
||||
double k;
|
||||
scanf("%d%lf",&n,&k);
|
||||
for( int i=0;i<n;i++ )
|
||||
scanf("%lf%lf",&pnt[i].x,&pnt[i].y);
|
||||
GetMap( n );
|
||||
cnt_edge = 0;
|
||||
LenPrim1 = prim( n,1 );
|
||||
Deal( n );
|
||||
LenPrim2 = prim( n,2 );
|
||||
double ans = LenPrim1;
|
||||
double temp_ans = 0;
|
||||
sort( edge,edge+cnt_edge,cmp );
|
||||
for( int i=0;i<cnt_edge;i++ ){
|
||||
if( edge[i].id==1 && edge[i].u!=0 && edge[i].v!=0 ){
|
||||
temp_ans = Kruskal( n,i );
|
||||
if( temp_ans>ans )
|
||||
ans = temp_ans;
|
||||
}
|
||||
}
|
||||
printf("%.2lf\n",ans*k);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define maxn 200010
|
||||
using namespace std;
|
||||
struct ww {
|
||||
int son[2];
|
||||
int cnt;
|
||||
ww() {
|
||||
cnt=0;
|
||||
memset(son,0,sizeof son);
|
||||
}
|
||||
}t[maxn<<5];
|
||||
int n,m,l,tot;
|
||||
int a[maxn],pre[maxn<<1],other[maxn<<1],last[maxn],que[maxn],dis[maxn],jump[maxn][20];
|
||||
void connect(int x,int y) {
|
||||
pre[++l]=last[x];
|
||||
last[x]=l;
|
||||
other[l]=y;
|
||||
}
|
||||
int lca(int x,int y) {
|
||||
if (dis[x]>dis[y]) swap(x,y);
|
||||
int dep=dis[y]-dis[x];
|
||||
for (int i=0;i<=18;i++) if (dep&(1<<i)) y=jump[y][i];
|
||||
if (x==y) return x;
|
||||
for (int i=18;i>=0;i--) if (jump[x][i]!=jump[y][i]) x=jump[x][i],y=jump[y][i];
|
||||
return jump[x][0];
|
||||
}
|
||||
void build(int &x,int dep) {
|
||||
if (!x) x=++tot;
|
||||
if (dep<0) return ;
|
||||
build(t[x].son[0],dep-1); build(t[x].son[1],dep-1);
|
||||
}
|
||||
void insert(int &x,int rot,int dep,int key) {
|
||||
if (!x) x=++tot;
|
||||
if (dep==-2) return ;
|
||||
if (key&(1<<dep)) {
|
||||
insert(t[x].son[1],t[rot].son[1],dep-1,key);
|
||||
t[x].son[0]=t[rot].son[0];
|
||||
} else {
|
||||
insert(t[x].son[0],t[rot].son[0],dep-1,key);
|
||||
t[x].son[1]=t[rot].son[1];
|
||||
}
|
||||
t[x].cnt+=t[rot].cnt+1;
|
||||
}
|
||||
int query(int rx,int lx,int key,int dep) {
|
||||
if (dep==-2) return 0;
|
||||
int ans=0;
|
||||
if (key&(1<<dep)) {
|
||||
if (t[t[rx].son[0]].cnt-t[t[lx].son[0]].cnt) {
|
||||
ans=1<<dep;
|
||||
ans+=query(t[rx].son[0],t[lx].son[0],key,dep-1);
|
||||
} else ans=query(t[rx].son[1],t[lx].son[1],key,dep-1);
|
||||
} else {
|
||||
if (t[t[rx].son[1]].cnt-t[t[lx].son[1]].cnt) {
|
||||
ans=1<<dep;
|
||||
ans+=query(t[rx].son[1],t[lx].son[1],key,dep-1);
|
||||
} else ans=query(t[rx].son[0],t[lx].son[0],key,dep-1);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void work() {
|
||||
memset(t,0,sizeof t);
|
||||
memset(last,0,sizeof last);
|
||||
memset(dis,0,sizeof dis);
|
||||
tot=n; l=0;
|
||||
for (int i=1;i<=n;i++) scanf("%d",&a[i]);
|
||||
for (int i=1;i<n;i++) {
|
||||
int x,y; scanf("%d%d",&x,&y);
|
||||
connect(x,y); connect(y,x);
|
||||
}
|
||||
int head=0,tail=1; que[1]=1; dis[1]=1;
|
||||
while (head<tail) {
|
||||
int cur=que[++head];
|
||||
for (int p=last[cur];p;p=pre[p]) {
|
||||
if (dis[other[p]]) continue;
|
||||
que[++tail]=other[p]; dis[other[p]]=dis[cur]+1;
|
||||
}
|
||||
}
|
||||
jump[1][0]=++tot;
|
||||
for (int i=1;i<=n;i++)
|
||||
for (int p=last[que[i]];p;p=pre[p])
|
||||
if (dis[other[p]]>dis[que[i]]) jump[other[p]][0]=que[i];
|
||||
for (int i=1;i<=18;i++)
|
||||
for (int j=1;j<=n;j++){
|
||||
int cur=que[j];
|
||||
jump[cur][i]=jump[jump[cur][i-1]][i-1];
|
||||
}
|
||||
build(jump[1][0],15);
|
||||
for (int i=1;i<=n;i++) insert(que[i],jump[que[i]][0],15,a[que[i]]);
|
||||
while (m--) {
|
||||
int x,y,z; scanf("%d%d%d",&x,&y,&z);
|
||||
int root=lca(x,y);
|
||||
int ans=0;
|
||||
ans=max(query(x,jump[root][0],z,15),query(y,jump[root][0],z,15));
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
while (scanf("%d%d",&n,&m)!=EOF) work();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int MOD = 1e9+7;
|
||||
int dp[110][110][220][4];
|
||||
int n,m;
|
||||
int ne[420][2],fail[420],en[420];
|
||||
int root,L;
|
||||
inline int change(char ch)
|
||||
{
|
||||
if(ch == 'R')return 0;
|
||||
else return 1;
|
||||
}
|
||||
inline int newnode()
|
||||
{
|
||||
for(int i = 0;i < 2;i++)
|
||||
ne[L][i] = -1;
|
||||
en[L++] = 0;
|
||||
return L-1;
|
||||
}
|
||||
inline void init()
|
||||
{
|
||||
L = 0;
|
||||
root = newnode();
|
||||
}
|
||||
inline void insert(char buf[],int id)
|
||||
{
|
||||
int len = strlen(buf);
|
||||
int now = root;
|
||||
for(int i = 0;i < len;i++)
|
||||
{
|
||||
if(ne[now][change(buf[i])] == -1)
|
||||
ne[now][change(buf[i])] = newnode();
|
||||
now = ne[now][change(buf[i])];
|
||||
}
|
||||
en[now] |= (1<<id);
|
||||
}
|
||||
inline void build()
|
||||
{
|
||||
queue<int>Q;
|
||||
fail[root] = root;
|
||||
for(int i = 0;i < 2;i++)
|
||||
if(ne[root][i] == -1)
|
||||
ne[root][i] = root;
|
||||
else
|
||||
{
|
||||
fail[ne[root][i]] = root;
|
||||
Q.push(ne[root][i]);
|
||||
}
|
||||
while( !Q.empty() )
|
||||
{
|
||||
int now = Q.front();
|
||||
Q.pop();
|
||||
en[now] |= en[fail[now]];
|
||||
for(int i = 0;i < 2;i++)
|
||||
if(ne[now][i] == -1)
|
||||
ne[now][i] = ne[fail[now]][i];
|
||||
else
|
||||
{
|
||||
fail[ne[now][i]]=ne[fail[now]][i];
|
||||
Q.push(ne[now][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
inline int solve()
|
||||
{
|
||||
dp[0][0][0][0] = 1;
|
||||
int ret = 0;
|
||||
for(int x = 0;x <= n;x++)
|
||||
for(int y = 0;y <= m;y++)
|
||||
for(int i = 0;i < L;i++)
|
||||
for(int k = 0;k < 4;k++)
|
||||
{
|
||||
if(dp[x][y][i][k] == 0)continue;
|
||||
if(x < n)
|
||||
{
|
||||
int nxt = ne[i][0];
|
||||
dp[x+1][y][nxt][k|en[nxt]] += dp[x][y][i][k];
|
||||
if(dp[x+1][y][nxt][k|en[nxt]] >= MOD)
|
||||
dp[x+1][y][nxt][k|en[nxt]] -= MOD;
|
||||
}
|
||||
if(y < m)
|
||||
{
|
||||
int nxt = ne[i][1];
|
||||
dp[x][y+1][nxt][k|en[nxt]] += dp[x][y][i][k];
|
||||
if(dp[x][y+1][nxt][k|en[nxt]] >= MOD)
|
||||
dp[x][y+1][nxt][k|en[nxt]] -= MOD;
|
||||
}
|
||||
}
|
||||
for(int i = 0;i < L;i++)
|
||||
{
|
||||
ret += dp[n][m][i][3];
|
||||
if(ret >= MOD)ret -= MOD;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
char str[210];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
init();
|
||||
for(int i = 0;i < 2;i++)
|
||||
{
|
||||
scanf("%s",str);
|
||||
insert(str,i);
|
||||
}
|
||||
build();
|
||||
for(int i = 0;i <= n;i++)
|
||||
for(int j = 0;j <= m;j++)
|
||||
for(int x = 0; x < L;x++)
|
||||
for(int y = 0;y < 4;y++)
|
||||
dp[i][j][x][y] = 0;
|
||||
printf("%d\n",solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,349 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
#define MAXN 9999
|
||||
#define MAXSIZE 1010
|
||||
#define DLEN 4
|
||||
class BigNum
|
||||
{
|
||||
public:
|
||||
int a[500];
|
||||
int len;
|
||||
public:
|
||||
BigNum(){len=1;memset(a,0,sizeof(a));}
|
||||
BigNum(const int);
|
||||
BigNum(const char*);
|
||||
BigNum(const BigNum &);
|
||||
BigNum &operator=(const BigNum &);
|
||||
friend istream& operator>>(istream&,BigNum&);
|
||||
friend ostream& operator<<(ostream&,BigNum&);
|
||||
BigNum operator+(const BigNum &)const;
|
||||
BigNum operator-(const BigNum &)const;
|
||||
BigNum operator*(const BigNum &)const;
|
||||
BigNum operator/(const int &)const;
|
||||
BigNum operator^(const int &)const;
|
||||
int operator%(const int &)const;
|
||||
bool operator>(const BigNum &T)const;
|
||||
bool operator>(const int &t)const;
|
||||
void print();
|
||||
};
|
||||
BigNum::BigNum(const int b)
|
||||
{
|
||||
int c,d=b;
|
||||
len=0;
|
||||
memset(a,0,sizeof(a));
|
||||
while(d>MAXN)
|
||||
{
|
||||
c=d-(d/(MAXN+1))*(MAXN+1);
|
||||
d=d/(MAXN+1);
|
||||
a[len++]=c;
|
||||
}
|
||||
a[len++]=d;
|
||||
}
|
||||
BigNum::BigNum(const char *s)
|
||||
{
|
||||
int t,k,index,L,i;
|
||||
memset(a,0,sizeof(a));
|
||||
L=strlen(s);
|
||||
len=L/DLEN;
|
||||
if(L%DLEN)len++;
|
||||
index=0;
|
||||
for(i=L-1;i>=0;i-=DLEN)
|
||||
{
|
||||
t=0;
|
||||
k=i-DLEN+1;
|
||||
if(k<0)k=0;
|
||||
for(int j=k;j<=i;j++)
|
||||
t=t*10+s[j]-'0';
|
||||
a[index++]=t;
|
||||
}
|
||||
}
|
||||
BigNum::BigNum(const BigNum &T):len(T.len)
|
||||
{
|
||||
int i;
|
||||
memset(a,0,sizeof(a));
|
||||
for(i=0;i<len;i++)
|
||||
a[i]=T.a[i];
|
||||
}
|
||||
BigNum & BigNum::operator=(const BigNum &n)
|
||||
{
|
||||
int i;
|
||||
len=n.len;
|
||||
memset(a,0,sizeof(a));
|
||||
for(i=0;i<len;i++)
|
||||
a[i]=n.a[i];
|
||||
return *this;
|
||||
}
|
||||
istream& operator>>(istream &in,BigNum &b)
|
||||
{
|
||||
char ch[MAXSIZE*4];
|
||||
int i=-1;
|
||||
in>>ch;
|
||||
int L=strlen(ch);
|
||||
int count=0,sum=0;
|
||||
for(i=L-1;i>=0;)
|
||||
{
|
||||
sum=0;
|
||||
int t=1;
|
||||
for(int j=0;j<4&&i>=0;j++,i--,t*=10)
|
||||
{
|
||||
sum+=(ch[i]-'0')*t;
|
||||
}
|
||||
b.a[count]=sum;
|
||||
count++;
|
||||
}
|
||||
b.len=count++;
|
||||
return in;
|
||||
}
|
||||
ostream& operator<<(ostream& out,BigNum& b)
|
||||
{
|
||||
int i;
|
||||
cout<<b.a[b.len-1];
|
||||
for(i=b.len-2;i>=0;i--)
|
||||
{
|
||||
printf("%04d",b.a[i]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
BigNum BigNum::operator+(const BigNum &T)const
|
||||
{
|
||||
BigNum t(*this);
|
||||
int i,big;
|
||||
big=T.len>len?T.len:len;
|
||||
for(i=0;i<big;i++)
|
||||
{
|
||||
t.a[i]+=T.a[i];
|
||||
if(t.a[i]>MAXN)
|
||||
{
|
||||
t.a[i+1]++;
|
||||
t.a[i]-=MAXN+1;
|
||||
}
|
||||
}
|
||||
if(t.a[big]!=0)
|
||||
t.len=big+1;
|
||||
else t.len=big;
|
||||
return t;
|
||||
}
|
||||
BigNum BigNum::operator-(const BigNum &T)const
|
||||
{
|
||||
int i,j,big;
|
||||
bool flag;
|
||||
BigNum t1,t2;
|
||||
if(*this>T)
|
||||
{
|
||||
t1=*this;
|
||||
t2=T;
|
||||
flag=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t1=T;
|
||||
t2=*this;
|
||||
flag=1;
|
||||
}
|
||||
big=t1.len;
|
||||
for(i=0;i<big;i++)
|
||||
{
|
||||
if(t1.a[i]<t2.a[i])
|
||||
{
|
||||
j=i+1;
|
||||
while(t1.a[j]==0)
|
||||
j++;
|
||||
t1.a[j--]--;
|
||||
while(j>i)
|
||||
t1.a[j--]+=MAXN;
|
||||
t1.a[i]+=MAXN+1-t2.a[i];
|
||||
}
|
||||
else t1.a[i]-=t2.a[i];
|
||||
}
|
||||
t1.len=big;
|
||||
while(t1.a[len-1]==0 && t1.len>1)
|
||||
{
|
||||
t1.len--;
|
||||
big--;
|
||||
}
|
||||
if(flag)
|
||||
t1.a[big-1]=0-t1.a[big-1];
|
||||
return t1;
|
||||
}
|
||||
BigNum BigNum::operator*(const BigNum &T)const
|
||||
{
|
||||
BigNum ret;
|
||||
int i,j,up;
|
||||
int temp,temp1;
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
up=0;
|
||||
for(j=0;j<T.len;j++)
|
||||
{
|
||||
temp=a[i]*T.a[j]+ret.a[i+j]+up;
|
||||
if(temp>MAXN)
|
||||
{
|
||||
temp1=temp-temp/(MAXN+1)*(MAXN+1);
|
||||
up=temp/(MAXN+1);
|
||||
ret.a[i+j]=temp1;
|
||||
}
|
||||
else
|
||||
{
|
||||
up=0;
|
||||
ret.a[i+j]=temp;
|
||||
}
|
||||
}
|
||||
if(up!=0)
|
||||
ret.a[i+j]=up;
|
||||
}
|
||||
ret.len=i+j;
|
||||
while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
|
||||
return ret;
|
||||
}
|
||||
BigNum BigNum::operator/(const int &b)const
|
||||
{
|
||||
BigNum ret;
|
||||
int i,down=0;
|
||||
for(i=len-1;i>=0;i--)
|
||||
{
|
||||
ret.a[i]=(a[i]+down*(MAXN+1))/b;
|
||||
down=a[i]+down*(MAXN+1)-ret.a[i]*b;
|
||||
}
|
||||
ret.len=len;
|
||||
while(ret.a[ret.len-1]==0 && ret.len>1)
|
||||
ret.len--;
|
||||
return ret;
|
||||
}
|
||||
int BigNum::operator%(const int &b)const
|
||||
{
|
||||
int i,d=0;
|
||||
for(i=len-1;i>=0;i--)
|
||||
d=((d*(MAXN+1))%b+a[i])%b;
|
||||
return d;
|
||||
}
|
||||
BigNum BigNum::operator^(const int &n)const
|
||||
{
|
||||
BigNum t,ret(1);
|
||||
int i;
|
||||
if(n<0)exit(-1);
|
||||
if(n==0)return 1;
|
||||
if(n==1)return *this;
|
||||
int m=n;
|
||||
while(m>1)
|
||||
{
|
||||
t=*this;
|
||||
for(i=1;(i<<1)<=m;i<<=1)
|
||||
t=t*t;
|
||||
m-=i;
|
||||
ret=ret*t;
|
||||
if(m==1)ret=ret*(*this);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
bool BigNum::operator>(const BigNum &T)const
|
||||
{
|
||||
int ln;
|
||||
if(len>T.len)return true;
|
||||
else if(len==T.len)
|
||||
{
|
||||
ln=len-1;
|
||||
while(a[ln]==T.a[ln]&&ln>=0)
|
||||
ln--;
|
||||
if(ln>=0 && a[ln]>T.a[ln])
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
bool BigNum::operator>(const int &t)const
|
||||
{
|
||||
BigNum b(t);
|
||||
return *this>b;
|
||||
}
|
||||
void BigNum::print()
|
||||
{
|
||||
int i;
|
||||
printf("%d",a[len-1]);
|
||||
for(i=len-2;i>=0;i--)
|
||||
printf("%04d",a[i]);
|
||||
printf("\n");
|
||||
}
|
||||
bool ONE(BigNum a)
|
||||
{
|
||||
if(a.len == 1 && a.a[0] == 1)return true;
|
||||
else return false;
|
||||
}
|
||||
BigNum A,B,X,Y;
|
||||
char str1[10010],str2[10010],str3[10010],str4[10010];
|
||||
int a[1010],b[1010],x[1010],y[1010];
|
||||
int c[1010];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
int iCase = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d",&n);
|
||||
cin>>A>>X>>B>>Y;
|
||||
printf("Case %d: ",iCase) ;
|
||||
A = A-1;
|
||||
X = X-1;
|
||||
B = B-1;
|
||||
Y = Y-1;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
if(A.a[0]%2 == 0)a[i] = 0;
|
||||
else a[i] = 1;
|
||||
if(B.a[0]%2 == 0)b[i] = 0;
|
||||
else b[i] = 1;
|
||||
if(X.a[0]%2 == 0)x[i] = 0;
|
||||
else x[i] = 1;
|
||||
if(Y.a[0]%2 == 0)y[i] = 0;
|
||||
else y[i] = 1;
|
||||
A = A/2;
|
||||
B = B/2;
|
||||
X = X/2;
|
||||
Y = Y/2;
|
||||
}
|
||||
bool flag = false;
|
||||
for(int k = 0;k <= n;k++)
|
||||
{
|
||||
x[n] = x[0];
|
||||
y[n] = y[0];
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
x[i] = x[i+1];
|
||||
y[i] = y[i+1];
|
||||
}
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
if(a[i] == x[i])c[i] = 0;
|
||||
else c[i] = 1;
|
||||
}
|
||||
bool fff = true;
|
||||
for(int i = 0;i < n;i++)
|
||||
if(b[i]^c[i] != y[i])
|
||||
{
|
||||
fff = false;
|
||||
break;
|
||||
}
|
||||
if(fff)flag = true;
|
||||
if(flag)break;
|
||||
}
|
||||
if(flag)printf("Yes\n");
|
||||
else printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#define pii pair<int,LL>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 100005;
|
||||
struct Trie {
|
||||
Trie *next[2];
|
||||
vector<pii> a;
|
||||
}*root , s[N << 2];
|
||||
char ope[10];
|
||||
int tot = 0 , can[N] , ok[1025] , idx = 0;
|
||||
LL ip (int a , int b , int c , int d) {
|
||||
LL ret = 0;
|
||||
ret |= (LL)a << 24;
|
||||
ret |= (LL)b << 16;
|
||||
ret |= (LL)c << 8;
|
||||
ret |= d;
|
||||
return ret;
|
||||
}
|
||||
Trie *newnode () {
|
||||
Trie *t = &s[tot ++];
|
||||
t -> next[0] = t -> next[1] = NULL;
|
||||
t -> a.clear();
|
||||
return t;
|
||||
}
|
||||
void insert (Trie *p , LL ip , int l , int id) {
|
||||
for (int i = 0 ; i < l ; i ++) {
|
||||
int c = (ip >> (31 - i)) & 1;
|
||||
if (p -> next[c] == NULL)
|
||||
p -> next[c] = newnode ();
|
||||
p = p -> next[c];
|
||||
}
|
||||
LL num = ip & ((1 << (32 - l)) - 1);
|
||||
p -> a.push_back (make_pair (id , num));
|
||||
}
|
||||
void down (LL ip) {
|
||||
Trie *p = root;
|
||||
for (int i = 31 ; i >= 0 ; i --) {
|
||||
int c = (ip >> i) & 1;
|
||||
if (p -> next[c] == NULL) return ;
|
||||
p = p -> next[c];
|
||||
for (int j = 0 ; j < p -> a.size() ; j ++) {
|
||||
if (can[p -> a[j].first] && p -> a[j].second <= (ip & ((1 << (i - 1)) - 1)))
|
||||
ok[p -> a[j].first] = idx;
|
||||
}
|
||||
}
|
||||
}
|
||||
bool up (LL ip) {
|
||||
Trie *p = root;
|
||||
for (int i = 31 ; i >= 0 ; i --) {
|
||||
int c = (ip >> i) & 1;
|
||||
if (p -> next[c] == NULL) return false;
|
||||
p = p -> next[c];
|
||||
for (int j = 0 ; j < p -> a.size() ; j ++) {
|
||||
if (can[p -> a[j].first] && p -> a[j].second <= (ip & ((1 << (i - 1)) - 1)) && ok[p -> a[j].first] == idx)
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main () {
|
||||
root = newnode ();
|
||||
while (scanf ("%s" , ope) != EOF) {
|
||||
if (ope[0] == 'E') {
|
||||
int id , k , a , b , c , d , u;
|
||||
scanf ("%d %d" , &id , &k);
|
||||
for (int i = 0 ; i < k ; i ++) {
|
||||
scanf ("%d.%d.%d.%d/%d" , &a , &b , &c , &d , &u);
|
||||
insert (root , ip (a , b , c , d) , u , id);
|
||||
}
|
||||
can[id] = 1;
|
||||
}
|
||||
else if (ope[0] == 'D') {
|
||||
int id;scanf ("%d" , &id);
|
||||
can[id] = 0;
|
||||
}
|
||||
else {
|
||||
idx ++;
|
||||
int a , b , c , d;
|
||||
scanf ("%d.%d.%d.%d" , &a , &b , &c , &d);
|
||||
down (ip (a , b , c , d));
|
||||
scanf ("%d.%d.%d.%d" , &a , &b , &c , &d);
|
||||
puts (up (ip (a , b , c , d)) ? "F" : "D");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,304 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
#define MAXN 9999
|
||||
#define MAXSIZE 1010
|
||||
#define DLEN 4
|
||||
class BigNum
|
||||
{
|
||||
private:
|
||||
int a[500];
|
||||
int len;
|
||||
public:
|
||||
BigNum(){len=1;memset(a,0,sizeof(a));}
|
||||
BigNum(const int);
|
||||
BigNum(const char*);
|
||||
BigNum(const BigNum &);
|
||||
BigNum &operator=(const BigNum &);
|
||||
friend istream& operator>>(istream&,BigNum&);
|
||||
friend ostream& operator<<(ostream&,BigNum&);
|
||||
BigNum operator+(const BigNum &)const;
|
||||
BigNum operator-(const BigNum &)const;
|
||||
BigNum operator*(const BigNum &)const;
|
||||
BigNum operator/(const int &)const;
|
||||
BigNum operator^(const int &)const;
|
||||
int operator%(const int &)const;
|
||||
bool operator>(const BigNum &T)const;
|
||||
bool operator>(const int &t)const;
|
||||
void print();
|
||||
};
|
||||
BigNum::BigNum(const int b)
|
||||
{
|
||||
int c,d=b;
|
||||
len=0;
|
||||
memset(a,0,sizeof(a));
|
||||
while(d>MAXN)
|
||||
{
|
||||
c=d-(d/(MAXN+1))*(MAXN+1);
|
||||
d=d/(MAXN+1);
|
||||
a[len++]=c;
|
||||
}
|
||||
a[len++]=d;
|
||||
}
|
||||
BigNum::BigNum(const char *s)
|
||||
{
|
||||
int t,k,index,L,i;
|
||||
memset(a,0,sizeof(a));
|
||||
L=strlen(s);
|
||||
len=L/DLEN;
|
||||
if(L%DLEN)len++;
|
||||
index=0;
|
||||
for(i=L-1;i>=0;i-=DLEN)
|
||||
{
|
||||
t=0;
|
||||
k=i-DLEN+1;
|
||||
if(k<0)k=0;
|
||||
for(int j=k;j<=i;j++)
|
||||
t=t*10+s[j]-'0';
|
||||
a[index++]=t;
|
||||
}
|
||||
}
|
||||
BigNum::BigNum(const BigNum &T):len(T.len)
|
||||
{
|
||||
int i;
|
||||
memset(a,0,sizeof(a));
|
||||
for(i=0;i<len;i++)
|
||||
a[i]=T.a[i];
|
||||
}
|
||||
BigNum & BigNum::operator=(const BigNum &n)
|
||||
{
|
||||
int i;
|
||||
len=n.len;
|
||||
memset(a,0,sizeof(a));
|
||||
for(i=0;i<len;i++)
|
||||
a[i]=n.a[i];
|
||||
return *this;
|
||||
}
|
||||
istream& operator>>(istream &in,BigNum &b)
|
||||
{
|
||||
char ch[MAXSIZE*4];
|
||||
int i=-1;
|
||||
in>>ch;
|
||||
int L=strlen(ch);
|
||||
int count=0,sum=0;
|
||||
for(i=L-1;i>=0;)
|
||||
{
|
||||
sum=0;
|
||||
int t=1;
|
||||
for(int j=0;j<4&&i>=0;j++,i--,t*=10)
|
||||
{
|
||||
sum+=(ch[i]-'0')*t;
|
||||
}
|
||||
b.a[count]=sum;
|
||||
count++;
|
||||
}
|
||||
b.len=count++;
|
||||
return in;
|
||||
}
|
||||
ostream& operator<<(ostream& out,BigNum& b)
|
||||
{
|
||||
int i;
|
||||
cout<<b.a[b.len-1];
|
||||
for(i=b.len-2;i>=0;i--)
|
||||
{
|
||||
printf("%04d",b.a[i]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
BigNum BigNum::operator+(const BigNum &T)const
|
||||
{
|
||||
BigNum t(*this);
|
||||
int i,big;
|
||||
big=T.len>len?T.len:len;
|
||||
for(i=0;i<big;i++)
|
||||
{
|
||||
t.a[i]+=T.a[i];
|
||||
if(t.a[i]>MAXN)
|
||||
{
|
||||
t.a[i+1]++;
|
||||
t.a[i]-=MAXN+1;
|
||||
}
|
||||
}
|
||||
if(t.a[big]!=0)
|
||||
t.len=big+1;
|
||||
else t.len=big;
|
||||
return t;
|
||||
}
|
||||
BigNum BigNum::operator-(const BigNum &T)const
|
||||
{
|
||||
int i,j,big;
|
||||
bool flag;
|
||||
BigNum t1,t2;
|
||||
if(*this>T)
|
||||
{
|
||||
t1=*this;
|
||||
t2=T;
|
||||
flag=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t1=T;
|
||||
t2=*this;
|
||||
flag=1;
|
||||
}
|
||||
big=t1.len;
|
||||
for(i=0;i<big;i++)
|
||||
{
|
||||
if(t1.a[i]<t2.a[i])
|
||||
{
|
||||
j=i+1;
|
||||
while(t1.a[j]==0)
|
||||
j++;
|
||||
t1.a[j--]--;
|
||||
while(j>i)
|
||||
t1.a[j--]+=MAXN;
|
||||
t1.a[i]+=MAXN+1-t2.a[i];
|
||||
}
|
||||
else t1.a[i]-=t2.a[i];
|
||||
}
|
||||
t1.len=big;
|
||||
while(t1.a[len-1]==0 && t1.len>1)
|
||||
{
|
||||
t1.len--;
|
||||
big--;
|
||||
}
|
||||
if(flag)
|
||||
t1.a[big-1]=0-t1.a[big-1];
|
||||
return t1;
|
||||
}
|
||||
BigNum BigNum::operator*(const BigNum &T)const
|
||||
{
|
||||
BigNum ret;
|
||||
int i,j,up;
|
||||
int temp,temp1;
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
up=0;
|
||||
for(j=0;j<T.len;j++)
|
||||
{
|
||||
temp=a[i]*T.a[j]+ret.a[i+j]+up;
|
||||
if(temp>MAXN)
|
||||
{
|
||||
temp1=temp-temp/(MAXN+1)*(MAXN+1);
|
||||
up=temp/(MAXN+1);
|
||||
ret.a[i+j]=temp1;
|
||||
}
|
||||
else
|
||||
{
|
||||
up=0;
|
||||
ret.a[i+j]=temp;
|
||||
}
|
||||
}
|
||||
if(up!=0)
|
||||
ret.a[i+j]=up;
|
||||
}
|
||||
ret.len=i+j;
|
||||
while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
|
||||
return ret;
|
||||
}
|
||||
BigNum BigNum::operator/(const int &b)const
|
||||
{
|
||||
BigNum ret;
|
||||
int i,down=0;
|
||||
for(i=len-1;i>=0;i--)
|
||||
{
|
||||
ret.a[i]=(a[i]+down*(MAXN+1))/b;
|
||||
down=a[i]+down*(MAXN+1)-ret.a[i]*b;
|
||||
}
|
||||
ret.len=len;
|
||||
while(ret.a[ret.len-1]==0 && ret.len>1)
|
||||
ret.len--;
|
||||
return ret;
|
||||
}
|
||||
int BigNum::operator%(const int &b)const
|
||||
{
|
||||
int i,d=0;
|
||||
for(i=len-1;i>=0;i--)
|
||||
d=((d*(MAXN+1))%b+a[i])%b;
|
||||
return d;
|
||||
}
|
||||
BigNum BigNum::operator^(const int &n)const
|
||||
{
|
||||
BigNum t,ret(1);
|
||||
int i;
|
||||
if(n<0)exit(-1);
|
||||
if(n==0)return 1;
|
||||
if(n==1)return *this;
|
||||
int m=n;
|
||||
while(m>1)
|
||||
{
|
||||
t=*this;
|
||||
for(i=1;(i<<1)<=m;i<<=1)
|
||||
t=t*t;
|
||||
m-=i;
|
||||
ret=ret*t;
|
||||
if(m==1)ret=ret*(*this);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
bool BigNum::operator>(const BigNum &T)const
|
||||
{
|
||||
int ln;
|
||||
if(len>T.len)return true;
|
||||
else if(len==T.len)
|
||||
{
|
||||
ln=len-1;
|
||||
while(a[ln]==T.a[ln]&&ln>=0)
|
||||
ln--;
|
||||
if(ln>=0 && a[ln]>T.a[ln])
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
bool BigNum::operator>(const int &t)const
|
||||
{
|
||||
BigNum b(t);
|
||||
return *this>b;
|
||||
}
|
||||
void BigNum::print()
|
||||
{
|
||||
int i;
|
||||
printf("%d",a[len-1]);
|
||||
for(i=len-2;i>=0;i--)
|
||||
printf("%04d",a[i]);
|
||||
printf("\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m,n;
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&m,&n);
|
||||
BigNum tt = 1;
|
||||
for(int i = 1;i < n;i++)
|
||||
tt = tt*m;
|
||||
int tmp = n;
|
||||
for(int i = 2;i <= n;i++)
|
||||
{
|
||||
while( tmp%i == 0 && (tt%i == 0) )
|
||||
{
|
||||
tmp /= i;
|
||||
tt = tt/i;
|
||||
}
|
||||
}
|
||||
printf("%d/",tmp);
|
||||
tt.print();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#define MAXN 1111111
|
||||
#define MAXM 211111
|
||||
#define PI acos(-1.0)
|
||||
#define eps 1e-8
|
||||
#define INF 1e10
|
||||
using namespace std;
|
||||
int A[MAXN], B[MAXN];
|
||||
char sa[MAXN];
|
||||
void preExKmp(char x[],int m,int A[]){
|
||||
int ind=0,k=1;
|
||||
A[0]=m;
|
||||
while (ind + 1 < m && x[ind+1]==x[ind]) ++ind;
|
||||
A[1]=ind;
|
||||
for (int i=2;i<m;++i){
|
||||
if (i<=k+A[k]-1 && A[i-k]+i<k+A[k])
|
||||
A[i]=A[i-k];
|
||||
else{
|
||||
ind=max(0,k+A[k]-i);
|
||||
while (ind + i < m && x[ind+i]==x[ind]) ++ind;
|
||||
A[i]=ind,k=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
void exKmp(char x[],int m , char y[],int n,int A[],int B[]){
|
||||
preExKmp(x,m,A);
|
||||
int ind=0,k=0;
|
||||
while (ind<n && ind<m && x[ind]==y[ind]) ind++;
|
||||
B[0]=ind;
|
||||
for (int i=1;i<n;++i){
|
||||
if (i < k+B[k]-1 && A[i-k]+i<k+B[k])
|
||||
B[i]=A[i-k];
|
||||
else{
|
||||
ind = max(0,k+B[k]-i);
|
||||
while (ind +i<n && ind<m && y[ind+i]==x[ind]) ++ind;
|
||||
B[i]=ind;k=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s", sa);
|
||||
int len = strlen(sa);
|
||||
preExKmp(sa, len, A);
|
||||
int ans = 0;
|
||||
int lst = len - len / 3, mxlen;
|
||||
for(int i = 0; i < len; i++)
|
||||
{
|
||||
mxlen = min(i, A[i]);
|
||||
mxlen = min(mxlen, (len - i) / 2);
|
||||
ans = max(ans, mxlen);
|
||||
}
|
||||
int res = 0;
|
||||
for(int i = lst; i < len; i++)
|
||||
{
|
||||
if(A[i] + i != len) continue;
|
||||
if(ans >= A[i])
|
||||
{
|
||||
res = A[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("%d\n", res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
int n,k;
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&k) == 2)
|
||||
{
|
||||
if(n == 0 && k == 0)break;
|
||||
if((n-1)%(k+1) == 0)printf("Jiang\n");
|
||||
else printf("Tang\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int maxn=1e3+9;
|
||||
const double inf=1e11,epx=0.00001;
|
||||
int n;
|
||||
double rx,ry,d;
|
||||
double x[maxn],y[maxn];
|
||||
double cal(double x1,double y1,double x2,double y2)
|
||||
{
|
||||
double a=(x1-x2)*(x1-x2);
|
||||
double b=(y1-y2)*(y1-y2);
|
||||
return sqrt(a+b);
|
||||
}
|
||||
bool chk(double xx,double yy)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
if(cal(xx,yy,x[i],y[i])>d+epx) return false;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%lf %lf",&rx,&ry)!=EOF)
|
||||
{
|
||||
scanf("%lf",&d);
|
||||
scanf("%d",&n);
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%lf %lf",&x[i],&y[i]);
|
||||
bool flag=false;
|
||||
double ans=inf;
|
||||
if(chk(rx,ry))
|
||||
{
|
||||
ans=0;
|
||||
flag=true;
|
||||
}
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
double tmp=cal(x[i],y[i],rx,ry);
|
||||
double xx=x[i]+(rx-x[i])*(d/tmp);
|
||||
double yy=y[i]+(ry-y[i])*(d/tmp);
|
||||
if(ans>cal(xx,yy,rx,ry))
|
||||
if(chk(xx,yy))
|
||||
{
|
||||
ans=cal(xx,yy,rx,ry);
|
||||
flag=true;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=i+1;j<=n;j++)
|
||||
{
|
||||
if(cal(x[i],y[i],x[j],y[j])>2*d+epx) continue;
|
||||
if(fabs(x[i]-x[j])<epx&&fabs(y[i]-y[j])<epx) continue;
|
||||
double x1=x[j]-x[i];
|
||||
double y1=y[j]-y[i];
|
||||
double xx=x[i]+x1/2,yy=y[i]+y1/2;
|
||||
double tmp=cal(xx,yy,x[i],y[i]);
|
||||
double txt=sqrt(d*d-tmp*tmp);
|
||||
double ex,ey;
|
||||
if(fabs(x1-0)>epx) ey=1,ex=-y1/x1;
|
||||
else ex=1,ey=-x1/y1;
|
||||
double tt=sqrt(ex*ex+ey*ey);
|
||||
xx+=txt*ex/tt;
|
||||
yy+=txt*ey/tt;
|
||||
if(cal(xx,yy,rx,ry)<ans)
|
||||
if(chk(xx,yy))
|
||||
{
|
||||
ans=cal(xx,yy,rx,ry);
|
||||
flag=true;
|
||||
}
|
||||
xx-=txt*ex*2/tt;
|
||||
yy-=txt*ey*2/tt;
|
||||
if(cal(xx,yy,rx,ry)<ans)
|
||||
if(chk(xx,yy))
|
||||
{
|
||||
ans=cal(xx,yy,rx,ry);
|
||||
flag=true;
|
||||
}
|
||||
}
|
||||
if(!flag) printf("X\n");
|
||||
else printf("%.2lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include <iostream>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define INF 0x7ffffffffffLL
|
||||
#define N 50
|
||||
#define LL long long
|
||||
#define mod 95041567
|
||||
using namespace std;
|
||||
LL num[N][N], q[N];
|
||||
int p[5] = {31, 37, 41, 43, 47}, arr[5];
|
||||
void Preprocessing(){
|
||||
q[0] = q[1]= 1;
|
||||
num[0][0] = num[1][0] = 1, num[1][1] = 2;
|
||||
for(int i = 2; i < 50; ++i){
|
||||
q[i] = num[i][0] = num[i - 1][i - 1];
|
||||
for(int j = 1; j <= i; ++j)
|
||||
num[i][j] = (num[i - 1][j - 1] + num[i][j - 1]) %mod;
|
||||
}
|
||||
}
|
||||
int cal(int x, LL n){
|
||||
int _q[N];
|
||||
for(int i = 0; i <= x; ++i) _q[i] = q[i] % x;
|
||||
int len = 0;
|
||||
int _mod[15];
|
||||
while(n){
|
||||
_mod[len++] = n % x;
|
||||
n /= x;
|
||||
}
|
||||
int _arr[N];
|
||||
for(int i = 1; i < len; ++i)
|
||||
for(int j = 1; j <= _mod[i]; ++j){
|
||||
for(int k = 0; k < x; ++k)
|
||||
_arr[k] = (_q[k] * i + _q[k + 1]) % x;
|
||||
_arr[x] = (_arr[0] + _arr[1]) % x;
|
||||
for(int k = 0; k <= x; ++k) _q[k] = _arr[k];
|
||||
}
|
||||
return _arr[_mod[0]];
|
||||
}
|
||||
void gcd(LL a, LL b, LL &x, LL &y){
|
||||
if(!b){
|
||||
x = 1;
|
||||
y = 0;
|
||||
return;
|
||||
}
|
||||
gcd(b, a % b, y, x);
|
||||
y -= a / b * x;
|
||||
}
|
||||
LL china(){
|
||||
LL d, y, x = 0;
|
||||
for(int i = 0; i < 5; ++i){
|
||||
LL w = mod / p[i];
|
||||
gcd(p[i], w, d, y);
|
||||
x = (x + y * w * arr[i]) % mod;
|
||||
}
|
||||
return (x + mod) % mod;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Preprocessing();
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t--){
|
||||
LL n;
|
||||
scanf("%I64d", &n);
|
||||
if(n < 50){
|
||||
printf("%I64d\n", q[n]);
|
||||
continue;
|
||||
}
|
||||
for(int i = 0; i < 5; ++i)
|
||||
arr[i] = cal(p[i], n);
|
||||
printf("%I64d\n", china());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define ll __int64
|
||||
#define L 20005
|
||||
ll a[L],b[L],c[L],l,r,n;
|
||||
ll solve(ll mid)
|
||||
{
|
||||
ll k,sum = 0;
|
||||
int i;
|
||||
for(i = 0; i<n; i++)
|
||||
{
|
||||
k = min(mid,b[i]);
|
||||
if(k>=a[i])
|
||||
sum+=(k-a[i])/c[i]+1;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(i = 0; i<n; i++)
|
||||
scanf("%I64d%I64d%I64d",&a[i],&b[i],&c[i]);
|
||||
l = 0,r = 1LL<<31;
|
||||
ll mid;
|
||||
while(l<r)
|
||||
{
|
||||
mid = (l+r)/2;
|
||||
if(solve(mid)%2) r = mid;
|
||||
else l = mid+1;
|
||||
}
|
||||
if(l == 1LL<<31)
|
||||
printf("DC Qiang is unhappy.\n");
|
||||
else
|
||||
{
|
||||
while(solve(l)%2==0)l--;
|
||||
printf("%I64d %I64d\n",l,solve(l)-solve(l-1));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int getnum(int x)
|
||||
{
|
||||
int sum=0;
|
||||
while(x)
|
||||
{
|
||||
sum+=x%2;
|
||||
x/=2;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int dir[4][2]={-1,0,0,1,1,0,0,-1};
|
||||
char map[210][210];
|
||||
int vis[210][210];
|
||||
int po[20][2];
|
||||
int num,n,m;
|
||||
int check(int x,int y)
|
||||
{
|
||||
if(x<1||y<1||x>n||y>m)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
int isok(int flag,int limit)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
int x=po[i][0],y=po[i][1];
|
||||
if(vis[x][y]==limit)
|
||||
continue;
|
||||
vis[x][y]=0;
|
||||
}
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
if((flag>>i)&1)
|
||||
{
|
||||
int x=po[i][0],y=po[i][1];
|
||||
if(check(x-1,y)&&map[x-1][y]=='#')
|
||||
return 0;
|
||||
if(!vis[x-1][y])
|
||||
vis[x-1][y]=1;
|
||||
if(check(x,y+1)&&map[x][y+1]=='#')
|
||||
return 0;
|
||||
if(!vis[x][y+1])
|
||||
vis[x][y+1]=1;
|
||||
if(!vis[x][y])
|
||||
vis[x][y]=1;
|
||||
}
|
||||
}
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
int x=po[i][0],y=po[i][1];
|
||||
if(vis[x][y]==0)
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)&&(n+m))
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
int i,j,k;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%s",map[i]+1);
|
||||
}
|
||||
num=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
if(map[i][j]=='.')
|
||||
{
|
||||
po[num][0]=i;
|
||||
po[num++][1]=j;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(num==0)
|
||||
{
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
int limit=1<<num,sum=10000;
|
||||
int ans=2100000000;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
int x=po[i][0],y=po[i][1],tmp=0;
|
||||
for(j=0;j<4;j++)
|
||||
{
|
||||
for(k=0;k<num;k++)
|
||||
{
|
||||
int xx=po[k][0],yy=po[k][1];
|
||||
vis[xx][yy]=0;
|
||||
}
|
||||
if((check(dir[j][0]+x,dir[j][1]+y)&&map[dir[j][0]+x][dir[j][1]+y]=='#')||(check(dir[(j+1)%4][0]+x,dir[(j+1)%4][1]+y)&&map[dir[(j+1)%4][0]+x][dir[(j+1)%4][1]+y]=='#'))
|
||||
continue;
|
||||
sum++;
|
||||
vis[dir[j][0]+x][dir[j][1]+y]=sum;
|
||||
vis[dir[(j+1)%4][0]+x][dir[(j+1)%4][1]+y]=sum;
|
||||
vis[x][y]=sum;
|
||||
for(k=0;k<limit;k++)
|
||||
{
|
||||
if((k>>i)&1)
|
||||
continue;
|
||||
if(isok(k,sum))
|
||||
{
|
||||
ans=min(ans,1+getnum(k));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ans==2100000000)
|
||||
printf("-1\n");
|
||||
else
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
int n,m;
|
||||
char g[110][110];
|
||||
int a[110][110];
|
||||
int sx,sy;
|
||||
int k;
|
||||
int dp[110][110][32];
|
||||
int px[10],py[10];
|
||||
struct Node
|
||||
{
|
||||
int x,y;
|
||||
int s;
|
||||
Node(int _x = 0,int _y = 0,int _s = 0)
|
||||
{
|
||||
x = _x;
|
||||
y = _y;
|
||||
s = _s;
|
||||
}
|
||||
};
|
||||
int mo[][2] = {{0,1},{0,-1},{1,0},{-1,0}};
|
||||
int bfs()
|
||||
{
|
||||
queue<Node>q;
|
||||
int s = 0;
|
||||
for(int i = 0;i < k;i++)
|
||||
if(sx == px[i] && sy == py[i])
|
||||
s = s|(1<<i);
|
||||
q.push(Node(sx,sy,s));
|
||||
memset(dp,-1,sizeof(dp));
|
||||
dp[sx][sy][s] = 0;
|
||||
while(!q.empty())
|
||||
{
|
||||
Node tmp = q.front();
|
||||
q.pop();
|
||||
if(tmp.s == ((1<<k) - 1))
|
||||
{
|
||||
return dp[tmp.x][tmp.y][tmp.s];
|
||||
}
|
||||
for(int i = 0;i < 4;i++)
|
||||
{
|
||||
int nx = tmp.x + mo[i][0];
|
||||
int ny = tmp.y + mo[i][1];
|
||||
int s = tmp.s;
|
||||
if(nx < 0 || nx >= n || ny < 0 || ny >= m)continue;
|
||||
if(a[nx][ny] == -2)continue;
|
||||
for(int j = 0;j < k;j++)
|
||||
if(nx == px[j] && ny == py[j])
|
||||
{
|
||||
s |= (1<<j);
|
||||
}
|
||||
if(dp[nx][ny][s] != -1)continue;
|
||||
dp[nx][ny][s] = dp[tmp.x][tmp.y][tmp.s] + 1;
|
||||
q.push(Node(nx,ny,s));
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m) == 2)
|
||||
{
|
||||
if(n == 0 && m == 0)break;
|
||||
for(int i = 0;i < n;i++)
|
||||
scanf("%s",g[i]);
|
||||
memset(a,-1,sizeof(a));
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = 0;j < m;j++)
|
||||
{
|
||||
if(g[i][j] == '@')
|
||||
{
|
||||
sx = i;
|
||||
sy = j;
|
||||
}
|
||||
if(g[i][j] == '#')
|
||||
a[i][j] = -2;
|
||||
}
|
||||
scanf("%d",&k);
|
||||
int x,y;
|
||||
for(int i = 0;i < k;i++)
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
x --;
|
||||
y--;
|
||||
px[i] = x;
|
||||
py[i] = y;
|
||||
}
|
||||
printf("%d\n",bfs());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 35;
|
||||
int n;
|
||||
int map1[N][N], map2[N][N];
|
||||
int a1[N][N], a2[N][N], a3[N][N];
|
||||
void Init() {
|
||||
memset(map1, 0, sizeof(map1));
|
||||
memset(map2, 0, sizeof(map2));
|
||||
for(int i = 0; i < n ; i++)
|
||||
for(int j = 0; j < n; j++)
|
||||
scanf("%d", &map1[i][j]);
|
||||
for(int i = 0; i < n ; i++)
|
||||
for(int j = 0; j < n; j++)
|
||||
scanf("%d", &map2[i][j]);
|
||||
for(int i = 0; i < n; i++)
|
||||
for(int j = 0; j < n; j++)
|
||||
a1[i][j] = map2[j][n-i-1];
|
||||
for(int i = 0; i < n; i++)
|
||||
for(int j = 0; j < n; j++)
|
||||
a2[i][j] = a1[j][n-i-1];
|
||||
for(int i = 0; i < n; i++)
|
||||
for(int j = 0; j < n; j++)
|
||||
a3[i][j] = a2[j][n-i-1];
|
||||
}
|
||||
int main() {
|
||||
while(scanf("%d", &n), n) {
|
||||
Init() ;
|
||||
int pwd1 = 0, pwd2 = 0, pwd3 = 0, pwd4 = 0;
|
||||
for(int i = 0; i < n; i++)
|
||||
for(int j = 0; j < n; j++) {
|
||||
if(map1[i][j] == map2[i][j]) pwd1++;
|
||||
if(map1[i][j] == a1[i][j]) pwd2++;
|
||||
if(map1[i][j] == a2[i][j]) pwd3++;
|
||||
if(map1[i][j] == a3[i][j]) pwd4++;
|
||||
}
|
||||
int sum = 0;
|
||||
if(pwd1 > sum) sum = pwd1;
|
||||
if(pwd2 > sum) sum = pwd2;
|
||||
if(pwd3 > sum) sum = pwd3;
|
||||
if(pwd4 > sum) sum = pwd4;
|
||||
printf("%d\n", sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#define eps 0.00000001
|
||||
double x_0, y_0;
|
||||
double a[5], b[5], c[5];
|
||||
double ansx[5], ansy[5], ansr[5];
|
||||
int flag[5];
|
||||
void exchange(double &x, double &y)
|
||||
{
|
||||
double tmp = x;
|
||||
x = y;
|
||||
y = tmp;
|
||||
return ;
|
||||
}
|
||||
double dis(double x_1, double y_1, double x_2, double y_2)
|
||||
{
|
||||
return sqrt((x_1 - x_2) * (x_1 - x_2) + (y_1 - y_2) * (y_1 - y_2));
|
||||
}
|
||||
void changepoint(double x, double y, double &ex, double &ey)
|
||||
{
|
||||
double d = dis(x, y, x_0, y_0);
|
||||
ey = y_0 + (y - y_0) / (d * d);
|
||||
ex = x_0 + (x - x_0) / (d * d);
|
||||
return ;
|
||||
}
|
||||
void changecircle(double x, double y, double r, double &ex, double &ey, double &er)
|
||||
{
|
||||
double x_1, y_1, x_2, y_2;
|
||||
if(fabs(x - x_0) < eps)
|
||||
{
|
||||
changepoint(x, y + r, x_1, y_1);
|
||||
changepoint(x, y- r, x_2, y_2);
|
||||
}
|
||||
else
|
||||
{
|
||||
double k = (y - y_0) / (x - x_0);
|
||||
double tmp = sqrt(r * r / (1 + k * k));
|
||||
changepoint(tmp + x, k * tmp + y, x_1, y_1);
|
||||
changepoint(-tmp + x, -k * tmp + y, x_2, y_2);
|
||||
}
|
||||
ex = (x_1 + x_2) / 2;
|
||||
ey = (y_1 + y_2) / 2;
|
||||
er = dis(x_1, y_1, x_2, y_2) / 2;
|
||||
return ;
|
||||
}
|
||||
void rotate(double s, double t, double &aa, double &bb, double &cc, double sinct, double cosct)
|
||||
{
|
||||
double tmpa = aa, tmpb = bb, tmpc = cc;
|
||||
aa = tmpa * cosct - tmpb * sinct;
|
||||
bb = tmpa * sinct + tmpb * cosct;
|
||||
cc = tmpc + tmpa * s * cosct + tmpa * t * sinct - tmpa * s
|
||||
- tmpb * s * sinct + tmpb * t * cosct - tmpb * t;
|
||||
return ;
|
||||
}
|
||||
void getline(double x_1, double y_1, double r_1, double x_2, double y_2, double r_2)
|
||||
{
|
||||
double tmpa, tmpb, tmpc;
|
||||
tmpa = y_2 - y_1;
|
||||
tmpb = x_1 - x_2;
|
||||
tmpc = y_1 * (x_1 - x_2) - x_1 * (y_1 - y_2);
|
||||
double d, detr;
|
||||
d = dis(x_1, y_1, x_2, y_2);
|
||||
detr = r_2 - r_1;
|
||||
double sinct = fabs(detr) / d;
|
||||
double cosct = sqrt(d * d - detr * detr) / d;
|
||||
double aa = tmpa, bb = tmpb, cc = tmpc;
|
||||
rotate(x_1, y_1, aa, bb, cc, sinct, cosct);
|
||||
a[0] = aa;
|
||||
b[0] = bb;
|
||||
c[0] = cc - r_1 * sqrt(a[0] * a[0] + b[0] * b[0]);
|
||||
aa = tmpa, bb = tmpb, cc = tmpc;
|
||||
rotate(x_1, y_1, aa, bb, cc, -sinct, cosct);
|
||||
a[1] = aa;
|
||||
b[1] = bb;
|
||||
c[1] = cc + r_1 * sqrt(a[1] * a[1] + b[1] * b[1]);
|
||||
return ;
|
||||
}
|
||||
void getcircle(double aa, double bb, double cc, int k)
|
||||
{
|
||||
if(fabs(aa * x_0 + bb * y_0 - cc) < eps)
|
||||
{
|
||||
flag[k] = 0;
|
||||
return ;
|
||||
}
|
||||
double s, t, ex, ey;
|
||||
s = (aa * cc + x_0 * bb * bb - aa * bb * y_0) / (aa * aa + bb * bb);
|
||||
t = (bb * cc - x_0 * aa * bb + aa * aa * y_0) / (aa * aa + bb * bb);
|
||||
changepoint(s, t, ex, ey);
|
||||
ansx[k] = (x_0 + ex) / 2;
|
||||
ansy[k] = (y_0 + ey) / 2;
|
||||
ansr[k] = dis(x_0, y_0, ex, ey) / 2;
|
||||
return ;
|
||||
}
|
||||
double x_00,y_00,x_11,y_11,x_22,y_22,r_11,r_22;
|
||||
bool check(double x, double y, double r)
|
||||
{
|
||||
if (fabs(dis(x,y,x_00,y_00) - r) < eps)
|
||||
if (fabs(dis(x,y,x_11,y_11) - r - r_11) < eps)
|
||||
if (fabs(dis(x,y,x_22,y_22) - r - r_22) < eps)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
double get_dis(double aa, double bb, double cc,double x, double y)
|
||||
{
|
||||
return fabs((aa*x + bb*y - cc)/sqrt(aa*aa + bb*bb));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T = 100;
|
||||
double x_1, y_1, r_1, x_2, y_2, r_2;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%lf%lf%lf", &x_1, &y_1, &r_1);
|
||||
scanf("%lf%lf%lf", &x_2, &y_2, &r_2);
|
||||
scanf("%lf%lf", &x_0, &y_0);
|
||||
x_00 = x_0;
|
||||
y_00 = y_0;
|
||||
x_11 = x_1;
|
||||
y_11 = y_1;
|
||||
x_22 = x_2;
|
||||
y_22 = y_2;
|
||||
r_11 = r_1;
|
||||
r_22 = r_2;
|
||||
double ex_1, ex_2, ey_1, ey_2, er_1, er_2;
|
||||
changecircle(x_1, y_1, r_1, ex_1, ey_1, er_1);
|
||||
changecircle(x_2, y_2, r_2, ex_2, ey_2, er_2);
|
||||
if(er_1 > er_2)
|
||||
{
|
||||
exchange(ex_1, ex_2);
|
||||
exchange(ey_1, ey_2);
|
||||
exchange(er_1, er_2);
|
||||
}
|
||||
getline(ex_1, ey_1, er_1, ex_2, ey_2, er_2);
|
||||
memset(flag, -1, sizeof(flag));
|
||||
getcircle(a[0], b[0], c[0], 0);
|
||||
getcircle(a[1], b[1], c[1], 1);
|
||||
int ans = 0;
|
||||
for (int i=0; i < 2;i++)
|
||||
{
|
||||
if (check(ansx[i],ansy[i],ansr[i])){
|
||||
ans++;
|
||||
flag[i] = 1;
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
for(int i = 0; i < 2; i++)
|
||||
{
|
||||
if(flag[i] == 1){
|
||||
printf("%.8lf %.8lf %.8lf\n", ansx[i], ansy[i], ansr[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 10010
|
||||
#define MP(x,y) make_pair(x,y)
|
||||
#define FI first
|
||||
#define SE second
|
||||
map<pair<int,int>,int>ma;
|
||||
const int dis[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
|
||||
struct _no
|
||||
{
|
||||
int x,y,c;
|
||||
int to[4];
|
||||
_no(int _x,int _y)
|
||||
{
|
||||
x=_x,y=_y;
|
||||
c=-1;
|
||||
for(int i=0;i<4;++i) to[i]=-1;
|
||||
}
|
||||
_no(){}
|
||||
}no[MAXN];
|
||||
int top,fa[MAXN],col[MAXN],xy[MAXN];
|
||||
int que[MAXN];
|
||||
bool vi[MAXN];
|
||||
int findfa(int n)
|
||||
{
|
||||
if(fa[n]!=n)
|
||||
fa[n]=findfa(fa[n]);
|
||||
return fa[n];
|
||||
}
|
||||
inline void smu(int a,int b)
|
||||
{
|
||||
a=findfa(a),b=findfa(b);
|
||||
if(a==b) return ;
|
||||
fa[b]=a;
|
||||
col[a]+=col[b];
|
||||
}
|
||||
void del(int h)
|
||||
{
|
||||
int he=0,ta=0;
|
||||
que[ta++]=h;
|
||||
while(he<ta)
|
||||
{
|
||||
h=que[he++];
|
||||
for(int i=0;i<4;++i)
|
||||
{
|
||||
int p=no[h].to[i];
|
||||
if(p!=-1)
|
||||
{
|
||||
if(no[p].c==no[h].c&&!vi[p])
|
||||
que[ta++]=p,vi[p]=1;
|
||||
else if(no[p].c==!no[h].c)
|
||||
++col[findfa(p)];
|
||||
}
|
||||
}
|
||||
no[h].c=-1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase,n;
|
||||
scanf("%d",&ncase);
|
||||
while (ncase--)
|
||||
{
|
||||
memset(vi,0,sizeof(vi));
|
||||
top=0;
|
||||
ma.clear();
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
int x,y;
|
||||
scanf("%d%d",&x,&y);
|
||||
if(ma.find(MP(x,y))==ma.end())
|
||||
{
|
||||
ma[MP(x,y)]=top;
|
||||
xy[i]=top;
|
||||
no[top++]=_no(x,y);
|
||||
}
|
||||
else xy[i]=ma[MP(x,y)];
|
||||
}
|
||||
for(int i=0;i<top;++i)
|
||||
for(int j=0;j<4;++j)
|
||||
{
|
||||
int tx=no[i].x+dis[j][0],ty=no[i].y+dis[j][1];
|
||||
map<pair<int,int>,int> ::iterator ite=ma.find(MP(tx,ty));
|
||||
if(ite!=ma.end())
|
||||
no[i].to[j]=ite->SE;
|
||||
}
|
||||
for(int i=0;i<n;++i) fa[i]=i,col[i]=0;
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
int p=xy[i];
|
||||
int c=no[p].c=i&1;
|
||||
vi[p]=0;
|
||||
for(int j=0;j<4;++j)
|
||||
{
|
||||
int tx=no[p].x+dis[j][0],ty=no[p].y+dis[j][1];
|
||||
if(tx>0&&ty>0&&(no[p].to[j]==-1||no[no[p].to[j]].c==-1))
|
||||
++col[p];
|
||||
}
|
||||
for(int j=0;j<4;++j)
|
||||
{
|
||||
int tmp=no[p].to[j];
|
||||
if(tmp!=-1&&no[tmp].c!=-1)
|
||||
{
|
||||
--col[findfa(tmp)];
|
||||
if(no[tmp].c==c)
|
||||
smu(tmp,p);
|
||||
}
|
||||
}
|
||||
for(int j=0;j<4;++j)
|
||||
{
|
||||
int tmp=no[p].to[j];
|
||||
if(tmp!=-1&&no[tmp].c==!c&&col[findfa(tmp)]==0)
|
||||
del(tmp);
|
||||
}
|
||||
for(int j=0;j<4;++j)
|
||||
{
|
||||
int tmp=no[p].to[j];
|
||||
if(tmp!=-1&&no[tmp].c==c&&col[findfa(tmp)]==0)
|
||||
del(tmp);
|
||||
}
|
||||
if(no[p].c!=-1&&col[findfa(p)]==0) del(p);
|
||||
}
|
||||
int nb=0,nw=0;
|
||||
for(int i=0;i<top;++i)
|
||||
if(no[i].c==0)
|
||||
++nb;
|
||||
else if(no[i].c==1)
|
||||
++nw;
|
||||
printf("%d %d\n",nb,nw);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,166 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<bitset>
|
||||
#define inf 0x3f3f3f3f
|
||||
#define Inf 0x3FFFFFFFFFFFFFFFLL
|
||||
#define eps 1e-6
|
||||
#define pi acos(-1.0)
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn=100000+10;
|
||||
const int Msize=61;
|
||||
int ch[maxn*Msize][2],size[maxn*Msize],tot;
|
||||
ll val[maxn*Msize],p[Msize];
|
||||
void Init()
|
||||
{
|
||||
ch[0][0]=ch[0][1]=0;
|
||||
tot=size[0]=0;
|
||||
val[0]=-1;
|
||||
}
|
||||
void Insert(ll x)
|
||||
{
|
||||
int u=0;
|
||||
for(int i=Msize-1;i>=0;--i)
|
||||
{
|
||||
int c=(x&p[i])>0;
|
||||
if(!ch[u][c])
|
||||
{
|
||||
ch[u][c]=++tot;
|
||||
ch[tot][0]=ch[tot][1]=0;
|
||||
size[tot]=0;val[tot]=-1;
|
||||
}
|
||||
u=ch[u][c];
|
||||
size[u]++;
|
||||
}
|
||||
val[u]=x;
|
||||
}
|
||||
struct Edge
|
||||
{
|
||||
int v;
|
||||
ll w;
|
||||
int next;
|
||||
Edge(int v=0,ll w=0,int next=0):v(v),w(w),next(next){}
|
||||
}edges[maxn<<1];
|
||||
struct Query
|
||||
{
|
||||
int id,k;
|
||||
bool operator <(const Query &a) const
|
||||
{
|
||||
return k<a.k;
|
||||
}
|
||||
}querys[maxn];
|
||||
int head[maxn],nEdge,n,m;
|
||||
ll xv[maxn],ans[maxn];
|
||||
void AddEdges(int u,int v,ll w)
|
||||
{
|
||||
edges[++nEdge]=Edge(v,w,head[u]);
|
||||
head[u]=nEdge;
|
||||
edges[++nEdge]=Edge(u,w,head[v]);
|
||||
head[v]=nEdge;
|
||||
}
|
||||
void dfs(int u,int fa,ll now)
|
||||
{
|
||||
xv[u]=now;
|
||||
Insert(now);
|
||||
for(int k=head[u];k!=-1;k=edges[k].next)
|
||||
{
|
||||
int v=edges[k].v;
|
||||
if(v==fa) continue;
|
||||
dfs(v,u,now^edges[k].w);
|
||||
}
|
||||
}
|
||||
struct Node
|
||||
{
|
||||
int k;
|
||||
ll num,mxv;
|
||||
bool operator <(const Node &a) const
|
||||
{
|
||||
return mxv<a.mxv;
|
||||
}
|
||||
bool next()
|
||||
{
|
||||
k++;
|
||||
if(k>=n) return false;
|
||||
int kk=k,u=0;
|
||||
for(int dep=Msize-1;dep>=0;--dep)
|
||||
{
|
||||
int c=((num&p[dep])>0)^1;
|
||||
int v=ch[u][c];
|
||||
if(v&&size[v]>=kk) u=ch[u][c];
|
||||
else if(v&&size[v]<kk)
|
||||
{
|
||||
kk-=size[v];
|
||||
u=ch[u][c^1];
|
||||
}
|
||||
else u=ch[u][c^1];
|
||||
}
|
||||
mxv=val[u]^num;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
void solve()
|
||||
{
|
||||
sort(querys,querys+m);
|
||||
priority_queue<Node>q;
|
||||
Node node;
|
||||
for(int i=1;i<=n;++i)
|
||||
{
|
||||
node.k=0;
|
||||
node.num=xv[i];
|
||||
if(node.next()) q.push(node);
|
||||
}
|
||||
memset(ans,0xff,sizeof(ans));
|
||||
int rank=0;
|
||||
ll tmp;
|
||||
for(int i=0;i<m;++i)
|
||||
{
|
||||
while(!q.empty()&&rank<querys[i].k)
|
||||
{
|
||||
rank++;
|
||||
node=q.top();q.pop();
|
||||
tmp=node.mxv;
|
||||
if(node.next()) q.push(node);
|
||||
}
|
||||
if(querys[i].k==rank&&querys[i].k!=(ll)n*(n-1))
|
||||
ans[querys[i].id]=tmp;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
p[0]=1;
|
||||
for(int i=1;i<Msize;++i) p[i]=p[i-1]<<1;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
if(n==0) break;
|
||||
memset(head,0xff,sizeof(head));
|
||||
nEdge=-1;
|
||||
Init();
|
||||
int u,v;
|
||||
ll w;
|
||||
for(int i=1;i<n;++i)
|
||||
{
|
||||
scanf("%d%d%I64d",&u,&v,&w);
|
||||
AddEdges(u,v,w);
|
||||
}
|
||||
dfs(1,-1,0);
|
||||
scanf("%d",&m);
|
||||
for(int i=0;i<m;++i)
|
||||
{
|
||||
scanf("%d",&querys[i].k);
|
||||
querys[i].id=i;
|
||||
}
|
||||
solve();
|
||||
for(int i=0;i<m;++i)
|
||||
printf("%I64d\n",ans[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int MAXN = 200010;
|
||||
int prime[MAXN+1];
|
||||
void getPrime()
|
||||
{
|
||||
memset(prime,0,sizeof(prime));
|
||||
for(int i = 2;i <= MAXN;i++)
|
||||
{
|
||||
if(!prime[i])prime[++prime[0]] = i;
|
||||
for(int j = 1;j <= prime[0] && prime[j] <= MAXN/i;j++)
|
||||
{
|
||||
prime[prime[j]*i] = 1;
|
||||
if(i % prime[j] == 0)break;
|
||||
}
|
||||
}
|
||||
}
|
||||
long long factor[100][2];
|
||||
int fatCnt;
|
||||
int getFactors(long long x)
|
||||
{
|
||||
fatCnt = 0;
|
||||
long long tmp = x;
|
||||
for(int i = 1;prime[i] <= tmp/prime[i];i++)
|
||||
{
|
||||
factor[fatCnt][1] = 0;
|
||||
if(tmp % prime[i] == 0)
|
||||
{
|
||||
factor[fatCnt][0] = prime[i];
|
||||
while(tmp % prime[i] == 0)
|
||||
{
|
||||
factor[fatCnt][1]++;
|
||||
tmp /= prime[i];
|
||||
}
|
||||
fatCnt++;
|
||||
}
|
||||
}
|
||||
if(tmp != 1)
|
||||
{
|
||||
factor[fatCnt][0] = tmp;
|
||||
factor[fatCnt++][1] = 1;
|
||||
}
|
||||
return fatCnt;
|
||||
}
|
||||
int L[MAXN],R[MAXN];
|
||||
int a[MAXN];
|
||||
int b[MAXN];
|
||||
int n,m;
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x & (-x);
|
||||
}
|
||||
int c[MAXN];
|
||||
void add(int i,int val)
|
||||
{
|
||||
if(i == 0)return;
|
||||
while(i <= n)
|
||||
{
|
||||
c[i] += val;
|
||||
i += lowbit(i);
|
||||
}
|
||||
}
|
||||
int sum(int i)
|
||||
{
|
||||
int s = 0;
|
||||
while(i > 0)
|
||||
{
|
||||
s += c[i];
|
||||
i -= lowbit(i);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
vector<int>vec[MAXN];
|
||||
struct Node
|
||||
{
|
||||
int l,r;
|
||||
int index;
|
||||
void input()
|
||||
{
|
||||
scanf("%d%d",&l,&r);
|
||||
}
|
||||
};
|
||||
bool cmp(Node p1,Node p2)
|
||||
{
|
||||
return p1.r < p2.r;
|
||||
}
|
||||
Node node[MAXN];
|
||||
int ans[MAXN];
|
||||
int pp[MAXN][15];
|
||||
int main()
|
||||
{
|
||||
getPrime();
|
||||
while(scanf("%d%d",&n,&m) == 2)
|
||||
{
|
||||
if(n == 0 && m == 0)break;
|
||||
for(int i = 1;i <= n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
for(int i = 0;i < m;i++)
|
||||
{
|
||||
node[i].input();
|
||||
node[i].index = i;
|
||||
}
|
||||
for(int i = 1;i < MAXN;i++)b[i] = n+1;
|
||||
for(int i = n;i >= 1;i--)
|
||||
{
|
||||
getFactors(a[i]);
|
||||
R[i] = n+1;
|
||||
pp[i][0] = fatCnt;
|
||||
for(int j = 0;j < fatCnt;j++)
|
||||
{
|
||||
R[i] = min(R[i],b[factor[j][0]]);
|
||||
b[factor[j][0]] = i;
|
||||
pp[i][j+1] = factor[j][0];
|
||||
}
|
||||
}
|
||||
for(int i = 1;i < MAXN;i++)b[i] = 0;
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
L[i] = 0;
|
||||
fatCnt = pp[i][0];
|
||||
for(int j = 0;j < fatCnt;j++)
|
||||
{
|
||||
factor[j][0] = pp[i][j+1];
|
||||
L[i] = max(L[i],b[factor[j][0]]);
|
||||
b[factor[j][0]] = i;
|
||||
}
|
||||
}
|
||||
sort(node,node+m,cmp);
|
||||
memset(c,0,sizeof(c));
|
||||
for(int i = 1; i <= n+1;i++)
|
||||
{
|
||||
c[i] = 0;
|
||||
vec[i].clear();
|
||||
}
|
||||
for(int i = 1;i <= n;i++)vec[R[i]].push_back(i);
|
||||
int id = 1;
|
||||
for(int i = 0;i < m;i++)
|
||||
{
|
||||
while(id <= n && id <= node[i].r)
|
||||
{
|
||||
add(L[id],1);
|
||||
int sz = vec[id].size();
|
||||
for(int j = 0;j < sz;j++)
|
||||
{
|
||||
int v = vec[id][j];
|
||||
add(L[v],-1);
|
||||
add(v,1);
|
||||
}
|
||||
id++;
|
||||
}
|
||||
ans[node[i].index] = sum(node[i].r) - sum(node[i].l-1);
|
||||
ans[node[i].index] = node[i].r - node[i].l +1 - ans[node[i].index];
|
||||
}
|
||||
for(int i = 0;i < m;i++)printf("%d\n",ans[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int N = 1 << 21;
|
||||
bool vis[N];
|
||||
int n,g,s,dp[N],score[N],a[22][9];
|
||||
void get_score()
|
||||
{
|
||||
int sum[9];
|
||||
for(int mask=0;mask<(1<<n);mask++)
|
||||
{
|
||||
memset(sum,0,sizeof(sum));
|
||||
for(int i=0;i<n;i++)
|
||||
if(mask >> i & 1 ^ 1)
|
||||
for(int j=1;j<=g;j++)
|
||||
sum[j] += a[i][j];
|
||||
int ans = 0;
|
||||
for(int j=1;j<=g;j++)
|
||||
ans += sum[j] / s;
|
||||
score[mask] = ans;
|
||||
}
|
||||
}
|
||||
int dfs(int mask)
|
||||
{
|
||||
if(vis[mask])
|
||||
return dp[mask];
|
||||
vis[mask] = true;
|
||||
int ret = 0;
|
||||
for(int i=0;i<n;i++)
|
||||
if(mask >> i & 1)
|
||||
{
|
||||
int __mask = mask ^ (1 << i);
|
||||
int _delta = score[__mask] - score[mask];
|
||||
if(_delta > 0)
|
||||
ret = max(ret,_delta + dfs(__mask));
|
||||
else
|
||||
ret = max(ret,score[0] - score[mask] - dfs(__mask));
|
||||
}
|
||||
return dp[mask] = ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%d%d",&g,&n,&s),g||n||s)
|
||||
{
|
||||
memset(vis,false,sizeof(vis));
|
||||
memset(a,0,sizeof(a));
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int num,color;
|
||||
scanf("%d",&num);
|
||||
while(num--)
|
||||
{
|
||||
scanf("%d",&color);
|
||||
a[i][color]++;
|
||||
}
|
||||
}
|
||||
get_score();
|
||||
printf("%d\n",2*dfs((1<<n)-1)-score[0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<bitset>
|
||||
#define inf 0x3f3f3f3f
|
||||
#define Inf 0x3FFFFFFFFFFFFFFFLL
|
||||
#define eps 1e-6
|
||||
#define pi acos(-1.0)
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn=200+5;
|
||||
const int mod=1e9+7;
|
||||
ll dp[maxn][maxn][maxn],C[maxn][maxn],A[maxn][maxn],pinv[maxn];
|
||||
ll pow_mod(ll x,ll n)
|
||||
{
|
||||
ll res=1;
|
||||
while(n)
|
||||
{
|
||||
if(n&1) res=res*x%mod;
|
||||
x=x*x%mod;
|
||||
n>>=1;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
ll inv(ll x)
|
||||
{
|
||||
return pow_mod(x,mod-2)%mod;
|
||||
}
|
||||
void Init()
|
||||
{
|
||||
memset(C,0,sizeof(C));
|
||||
C[0][0]=1;
|
||||
for(int i=1;i<maxn;++i)
|
||||
{
|
||||
C[i][0]=1;
|
||||
for(int j=1;j<maxn;++j)
|
||||
{
|
||||
C[i][j]=C[i-1][j-1]+C[i-1][j];
|
||||
if(C[i][j]>=mod) C[i][j]-=mod;
|
||||
}
|
||||
}
|
||||
memset(A,0,sizeof(A));
|
||||
A[0][0]=1;
|
||||
for(int i=1;i<maxn;++i)
|
||||
{
|
||||
A[i][0]=1;
|
||||
for(int j=i;j>=1;--j)
|
||||
A[i][j]=A[i-1][j-1]*i%mod;
|
||||
}
|
||||
ll x=1;
|
||||
pinv[0]=inv(x);
|
||||
for(int i=1;i<maxn;++i)
|
||||
{
|
||||
x=(x<<1)%mod;
|
||||
pinv[i]=inv(x);
|
||||
}
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(int i=0;i<maxn;++i)
|
||||
for(int j=0;j<maxn;++j)
|
||||
dp[i][j][0]=1;
|
||||
for(int k=1;k<maxn;++k)
|
||||
for(int i=1;i<maxn;++i)
|
||||
for(int j=1;j<maxn;++j)
|
||||
dp[i][j][k]=(dp[i][j][k-1]+C[i][k]*A[j][k])%mod;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Init();
|
||||
int t,n,m,p,q;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d%d%d",&n,&m,&p,&q);
|
||||
ll ans=0,tmp,tmp2;
|
||||
for(int x=0;x<=q;++x)
|
||||
for(int i=0;i*2<=p;++i)
|
||||
for(int j=0;i*2+j*2<=p;++j)
|
||||
{
|
||||
int N=n-i-j*2-x;
|
||||
int M=m-i*2-j-x;
|
||||
if(N<0||M<0) continue;
|
||||
tmp2=C[n][x]*A[m][x]%mod;
|
||||
int tot=min(N*M,p-i*2-j*2);
|
||||
tmp=C[n-x][i]*A[m-x][i*2]%mod*pinv[i]%mod;
|
||||
tmp=tmp*C[m-i*2-x][j]%mod*A[n-i-x][j*2]%mod*pinv[j]%mod;
|
||||
if(i||j||x)
|
||||
ans=(ans+dp[N][M][tot]*tmp2%mod*tmp)%mod;
|
||||
else ans=((ans+dp[N][M][tot]-1)*tmp2%mod*tmp)%mod;
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int N = 510;
|
||||
const int M = 1000010;
|
||||
const int INF = 0x7f7f7f7f;
|
||||
struct Edge {
|
||||
int v, cap, cost, next;
|
||||
Edge() {}
|
||||
Edge(int a, int b, int c, int d)
|
||||
:v(a), cap(b), cost(c), next(d) {}
|
||||
}e[M];
|
||||
int head[N], sz;
|
||||
int dis[N], pre[N], cur[N];
|
||||
bool inq[N];
|
||||
queue<int> q;
|
||||
void graphinit() {
|
||||
memset(head, -1, sizeof(head));
|
||||
sz = 0;
|
||||
}
|
||||
void addedge(int u, int v, int cp, int ct) {
|
||||
e[sz] = Edge(v, cp, ct, head[u]);
|
||||
head[u] = sz++;
|
||||
e[sz] = Edge(u, 0, -ct, head[v]);
|
||||
head[v] = sz++;
|
||||
}
|
||||
pair<int, int> mcmf(int s, int t) {
|
||||
int mc = 0, mf = 0;
|
||||
while (true) {
|
||||
memset(pre, -1, sizeof(pre));
|
||||
memset(inq, 0, sizeof(inq));
|
||||
memset(dis, 0x7f, sizeof(dis));
|
||||
dis[s] = 0;
|
||||
q.push(s);
|
||||
while (!q.empty()) {
|
||||
int u = q.front(); q.pop();
|
||||
inq[u] = false;
|
||||
for (int i = head[u]; i != -1; i = e[i].next) {
|
||||
int v = e[i].v;
|
||||
if (e[i].cap > 0 && dis[v] > dis[u] + e[i].cost) {
|
||||
dis[v] = dis[u] + e[i].cost;
|
||||
pre[v] = u; cur[v] = i;
|
||||
if (!inq[v]) { inq[v] = true; q.push(v); }
|
||||
}
|
||||
}
|
||||
}
|
||||
if (pre[t] == -1) break;
|
||||
int aug = INF;
|
||||
for (int i = t; i != s; i = pre[i])
|
||||
aug = min(aug, e[cur[i]].cap);
|
||||
mf += aug;
|
||||
mc += dis[t] * aug;
|
||||
for (int i = t; i != s; i = pre[i]) {
|
||||
e[cur[i]].cap -= aug;
|
||||
e[cur[i] ^ 1].cap += aug;
|
||||
}
|
||||
}
|
||||
return make_pair(mf, mc);
|
||||
}
|
||||
const int MAXN = 110;
|
||||
int n, m, k;
|
||||
int candy_s[MAXN], candy_t[MAXN];
|
||||
int start_time[MAXN][MAXN], start_cost[MAXN][MAXN];
|
||||
int change_time[MAXN][MAXN], change_cost[MAXN][MAXN];
|
||||
void read_matrix(int a[MAXN][MAXN], int n, int m) {
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = 0; j < m; j++)
|
||||
scanf("%d", &a[i][j]);
|
||||
}
|
||||
void work() {
|
||||
for (int i = 0; i < n; i++)
|
||||
scanf("%d%d", candy_s + i, candy_t + i);
|
||||
read_matrix(start_time, n, m);
|
||||
read_matrix(start_cost, n, m);
|
||||
read_matrix(change_time, n, n);
|
||||
read_matrix(change_cost, n, n);
|
||||
graphinit();
|
||||
int ss = 2 * n + m, tt = ss + 1;
|
||||
for (int i = 0; i < n; i++)
|
||||
addedge(ss, i, 1, 0);
|
||||
for (int i = 0; i < m; i++)
|
||||
addedge(i + n, tt, 1, 0);
|
||||
for (int i = 0; i < n; i++)
|
||||
addedge(i + n + m, tt, 1, 0);
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = 0; j < m; j++) {
|
||||
if (start_time[i][j] >= candy_t[i]) continue;
|
||||
int cost = start_cost[i][j];
|
||||
if (start_time[i][j] > candy_s[i])
|
||||
cost += k * (start_time[i][j] - candy_s[i]);
|
||||
addedge(i, j + n, 1, cost);
|
||||
}
|
||||
for (int i = 0; i < n; i++)
|
||||
for (int j = 0; j < n; j++) if (i != j) {
|
||||
int dt = candy_t[i] + change_time[i][j];
|
||||
if (dt >= candy_t[j]) continue;
|
||||
int cost = change_cost[i][j];
|
||||
dt -= candy_s[j];
|
||||
if (dt > 0)
|
||||
cost += k * dt;
|
||||
addedge(j, i + n + m, 1, cost);
|
||||
}
|
||||
pair<int, int> ans = mcmf(ss, tt);
|
||||
if (ans.first < n) puts("-1");
|
||||
else printf("%d\n", ans.second);
|
||||
}
|
||||
int main() {
|
||||
while (scanf("%d%d%d", &n, &m, &k), n || m || k) {
|
||||
work();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int n,m;
|
||||
int map[85][85],sum[85],vis[5010];
|
||||
int has[3]={0,2,0};
|
||||
struct edge
|
||||
{
|
||||
int from,to,len;
|
||||
}ans[5010];
|
||||
int solve(int len,int num)
|
||||
{
|
||||
int tmp=len%3;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
if(i!=j&&!map[i][j]&&!map[j][i])
|
||||
{
|
||||
if(j>i)
|
||||
{
|
||||
if((sum[j]-sum[i]+3)%3==tmp)
|
||||
{
|
||||
map[i][j]=1;
|
||||
ans[num].from=i;
|
||||
ans[num].to=j;
|
||||
ans[num].len=len;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if((sum[i]-sum[j]+3+tmp)%3==0)
|
||||
{
|
||||
map[i][j]=1;
|
||||
ans[num].from=i;
|
||||
ans[num].to=j;
|
||||
ans[num].len=len;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase,T=0;
|
||||
scanf("%d",&ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(map,0,sizeof(map));
|
||||
memset(sum,0,sizeof(sum));
|
||||
scanf("%d%d",&n,&m);
|
||||
sum[1]=0;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
ans[i].from=i;
|
||||
ans[i].to=i+1;
|
||||
ans[i].len=i;
|
||||
vis[i]=1;
|
||||
map[ans[i].from][ans[i].to]=1;
|
||||
if(i!=1)
|
||||
sum[i]=(sum[i-1]+i-1)%3;
|
||||
}
|
||||
ans[n].from=n;
|
||||
ans[n].to=1;
|
||||
map[n][1]=1;
|
||||
ans[n].len=n+has[n%3];
|
||||
vis[ans[n].len]=1;
|
||||
sum[n]=(sum[n-1]+n-1)%3;
|
||||
int num=n,tru=1;
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
if(!vis[i])
|
||||
{
|
||||
tru=solve(i,++num);
|
||||
if(!tru)
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("Case #%d:\n",++T);
|
||||
if(!tru)
|
||||
{
|
||||
printf("-1\n");
|
||||
continue;
|
||||
}
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
printf("%d %d %d\n",ans[i].from,ans[i].to,ans[i].len);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int maxn = 10005;
|
||||
char buf[maxn];
|
||||
int len;
|
||||
char ch;
|
||||
void skip(){
|
||||
while(ch == ' ' || ch == '\t' || ch == '\n') ch = getchar();
|
||||
}
|
||||
void readTag(){
|
||||
len = 0;
|
||||
ch = getchar();
|
||||
while(ch!='>'){
|
||||
buf[len++] = ch;
|
||||
ch = getchar();
|
||||
}
|
||||
buf[len] = 0;
|
||||
}
|
||||
void readString(){
|
||||
len = 0;
|
||||
while(ch != ' ' && ch != '\t' && ch != '\n' && ch != '<'){
|
||||
buf[len++] = ch;
|
||||
ch = getchar();
|
||||
}
|
||||
buf[len] = 0;
|
||||
}
|
||||
void solve(){
|
||||
ch = ' ';
|
||||
int dep = 0;
|
||||
while(1){
|
||||
skip();
|
||||
if(ch == '<'){
|
||||
readTag();
|
||||
if(buf[len-1] == '/'){
|
||||
for(int i = 0; i < dep; i++) putchar(' ');
|
||||
}
|
||||
else if(buf[0] == '/') {
|
||||
dep--;
|
||||
for(int i = 0; i < dep; i++) putchar(' ');
|
||||
}
|
||||
else{
|
||||
for(int i = 0; i < dep; i++) putchar(' ');
|
||||
dep++;
|
||||
}
|
||||
printf("<%s>\n", buf);
|
||||
if(strcmp(buf, "/html") == 0)
|
||||
break;
|
||||
ch = getchar();
|
||||
}else{
|
||||
readString();
|
||||
for(int i = 0; i < dep; i++) putchar(' ');
|
||||
printf("%s", buf);
|
||||
skip();
|
||||
while( ch != '<' ){
|
||||
readString();
|
||||
printf(" %s", buf);
|
||||
skip();
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int t, cas = 1;
|
||||
scanf("%d", &t);
|
||||
while(t--) {
|
||||
printf("Case #%d:\n", cas++);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxn=100+10;
|
||||
const int maxm=200+10;
|
||||
struct Edge
|
||||
{
|
||||
int v,tm,cost;
|
||||
int next;
|
||||
};
|
||||
Edge edges[maxm<<1];
|
||||
int head[maxn],nEdge=-1;
|
||||
int n,m,B,K,R,T;
|
||||
int d[maxn][210][6][6];
|
||||
bool inq[maxn][210][6][6];
|
||||
int prices[6][maxn];
|
||||
void AddEdge(int u,int v,int tm,int cost)
|
||||
{
|
||||
nEdge++;
|
||||
edges[nEdge].v=v;
|
||||
edges[nEdge].tm=tm;
|
||||
edges[nEdge].cost=cost;
|
||||
edges[nEdge].next=head[u];
|
||||
head[u]=nEdge;
|
||||
}
|
||||
struct Node
|
||||
{
|
||||
int u,times,k,b;
|
||||
bool operator < (const Node &a) const
|
||||
{
|
||||
return times>a.times;
|
||||
}
|
||||
};
|
||||
int bfs()
|
||||
{
|
||||
memset(d,0xff,sizeof(d));
|
||||
memset(inq,0,sizeof(inq));
|
||||
d[1][0][0][0]=R;
|
||||
Node node,tmp;
|
||||
priority_queue<Node>q;
|
||||
node.u=1;node.times=0;
|
||||
node.k=0;node.b=0;
|
||||
inq[1][0][0][0]=true;
|
||||
q.push(node);
|
||||
bool flag=false;
|
||||
while(!q.empty())
|
||||
{
|
||||
node=q.top();q.pop();
|
||||
if(node.times>T) break;
|
||||
int u=node.u;
|
||||
if(u==n) continue;
|
||||
for(int i=head[u];i!=-1;i=edges[i].next)
|
||||
{
|
||||
int v=edges[i].v;
|
||||
int cost,tim;
|
||||
cost=d[u][node.times][node.k][node.b]-edges[i].cost;
|
||||
tim=node.times+edges[i].tm;
|
||||
if(tim>T||cost<0) continue;
|
||||
if(v==n&&node.k!=0) continue;
|
||||
if(v==n) flag=true;
|
||||
tmp.u=v;tmp.times=tim;
|
||||
tmp.k=node.k;
|
||||
if(u!=1&&u!=n)
|
||||
{
|
||||
if(node.b+1<=B&&cost-prices[node.k][u]>d[v][tim][node.k][node.b+1])
|
||||
{
|
||||
d[v][tim][node.k][node.b+1]=cost-prices[node.k][u];
|
||||
tmp.b=node.b+1;
|
||||
if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
|
||||
{q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
|
||||
}
|
||||
if(node.b>0&&cost+prices[node.k][u]>d[v][tim][node.k][node.b-1])
|
||||
{
|
||||
d[v][tim][node.k][node.b-1]=cost+prices[node.k][u];
|
||||
tmp.b=node.b-1;
|
||||
if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
|
||||
{q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
|
||||
}
|
||||
}
|
||||
if(cost>d[v][tim][node.k][node.b])
|
||||
{
|
||||
d[v][tim][node.k][node.b]=cost;
|
||||
tmp.b=node.b;
|
||||
if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
|
||||
{q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
|
||||
}
|
||||
}
|
||||
if(u!=1&&u!=n)
|
||||
{
|
||||
int cost=d[u][node.times][node.k][node.b];
|
||||
tmp.u=u;tmp.k=(node.k+1)%K;
|
||||
tmp.times=node.times+1;
|
||||
if(tmp.times>T) continue;
|
||||
if(node.b+1<=B&&cost-prices[node.k][u]>d[u][tmp.times][tmp.k][node.b+1])
|
||||
{
|
||||
d[u][tmp.times][tmp.k][node.b+1]=cost-prices[node.k][u];
|
||||
tmp.b=node.b+1;
|
||||
if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
|
||||
{q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
|
||||
}
|
||||
if(node.b>0&&cost+prices[node.k][u]>d[u][tmp.times][tmp.k][node.b-1])
|
||||
{
|
||||
d[u][tmp.times][tmp.k][node.b-1]=cost+prices[node.k][u];
|
||||
tmp.b=node.b-1;
|
||||
if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
|
||||
{q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
|
||||
}
|
||||
tmp.b=node.b;
|
||||
if(cost>d[u][tmp.times][tmp.k][tmp.b])
|
||||
{
|
||||
d[u][tmp.times][tmp.k][tmp.b]=cost;
|
||||
if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
|
||||
{q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!flag) return -1;
|
||||
int ans=0;
|
||||
for(int i=0;i<=T;++i)
|
||||
for(int j=0;j<=B;++j)
|
||||
ans=max(ans,d[n][i][0][j]);
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,tcase=0;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
tcase++;
|
||||
scanf("%d%d%d%d%d%d",&n,&m,&B,&K,&R,&T);
|
||||
memset(head,0xff,sizeof(head));
|
||||
nEdge=-1;
|
||||
int u,v,tm,cost;
|
||||
for(int i=0;i<K;++i)
|
||||
for(int j=1;j<=n;++j)
|
||||
scanf("%d",&prices[i][j]);
|
||||
for(int i=0;i<m;++i)
|
||||
{
|
||||
scanf("%d%d%d%d",&u,&v,&tm,&cost);
|
||||
AddEdge(u,v,tm,cost);
|
||||
}
|
||||
int ans=bfs();
|
||||
printf("Case #%d: ",tcase);
|
||||
if(ans!=-1) printf("%d\n",ans);
|
||||
else printf("Forever Alone\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int fib[30];
|
||||
struct st
|
||||
{
|
||||
int l,r,c;
|
||||
}edge[100005];
|
||||
int fa[100005];
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
return (*(st*)b).c-(*(st*)a).c;
|
||||
}
|
||||
int getfa(int a)
|
||||
{
|
||||
if(0==fa[a])
|
||||
return a;
|
||||
else
|
||||
return fa[a]=getfa(fa[a]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
fib[0]=1,fib[1]=2;
|
||||
int flag;
|
||||
for(int i=2;fib[i-1]<=100000;i++)
|
||||
{
|
||||
fib[i]=fib[i-1]+fib[i-2];
|
||||
}
|
||||
int t,ti=1;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
int n,m;
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d%d%d",&edge[i].l,&edge[i].r,&edge[i].c);
|
||||
}
|
||||
memset(fa,0,sizeof(fa));
|
||||
qsort(edge+1,m,sizeof(edge[0]),cmp);
|
||||
int hi=0,sum=0;
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
int x=getfa(edge[i].l);
|
||||
int y=getfa(edge[i].r);
|
||||
if(x!=y)
|
||||
{
|
||||
fa[x]=y;
|
||||
hi+=edge[i].c;
|
||||
sum++;
|
||||
}
|
||||
}
|
||||
if(sum!=n-1)
|
||||
{
|
||||
printf("Case #%d: No\n",ti);
|
||||
ti++;
|
||||
continue;
|
||||
}
|
||||
int lo=0;
|
||||
memset(fa,0,sizeof(fa));
|
||||
for(int i=m;i>0;i--)
|
||||
{
|
||||
int x=getfa(edge[i].l);
|
||||
int y=getfa(edge[i].r);
|
||||
if(x!=y)
|
||||
{
|
||||
fa[x]=y;
|
||||
lo+=edge[i].c;
|
||||
}
|
||||
}
|
||||
flag=0;
|
||||
int i=0;
|
||||
while(fib[i]<=hi)
|
||||
{
|
||||
if(fib[i]>=lo&&fib[i]<=hi)
|
||||
{
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if(flag==1)
|
||||
printf("Case #%d: Yes\n",ti);
|
||||
else
|
||||
printf("Case #%d: No\n",ti);
|
||||
ti++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#pragma comment( linker, "/STACK:1024000000,1024000000")
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define maxnode 511111
|
||||
#define sigma_size 2
|
||||
struct Trie{
|
||||
int ch[maxnode][sigma_size];
|
||||
bool val[maxnode];
|
||||
int f[maxnode];
|
||||
int sz;
|
||||
void init(){
|
||||
sz=1;
|
||||
memset(ch,0,sizeof(ch));
|
||||
memset(val, 0, sizeof(val));
|
||||
memset(f,0,sizeof(f));
|
||||
}
|
||||
int idx(char c){ return c-'0'; }
|
||||
int insert(char *s){
|
||||
int u = 0;
|
||||
for(int i = 0; s[i] ;i++){
|
||||
int c = idx(s[i]);
|
||||
if(!ch[u][c])
|
||||
ch[u][c] = sz++;
|
||||
u = ch[u][c];
|
||||
}
|
||||
val[u] = 1;
|
||||
return u;
|
||||
}
|
||||
bool search(char *s){
|
||||
int u = 0;
|
||||
for(int i = 0; s[i] ;i++){
|
||||
int c = idx(s[i]);
|
||||
if(!ch[u][c]) return 0;
|
||||
u = ch[u][c];
|
||||
}
|
||||
return val[u];
|
||||
}
|
||||
void getFail(){
|
||||
queue<int> q;
|
||||
for(int i = 0; i<sigma_size; i++)
|
||||
if(ch[0][i]) q.push(ch[0][i]);
|
||||
while(!q.empty()){
|
||||
int r = q.front(); q.pop();
|
||||
for(int c = 0; c<sigma_size; c++){
|
||||
int u = ch[r][c];
|
||||
if(!u)continue;
|
||||
q.push(u);
|
||||
int v = f[r];
|
||||
while(v && ch[v][c] == 0) v = f[v];
|
||||
f[u] = ch[v][c];
|
||||
}
|
||||
}
|
||||
}
|
||||
int find(char *T){
|
||||
int j = 0, ans = 0;
|
||||
for(int i = 0; T[i] ; i++){
|
||||
int c = idx(T[i]);
|
||||
while(j && ch[j][c]==0) j = f[j];
|
||||
j = ch[j][c];
|
||||
int temp = j;
|
||||
while(temp){
|
||||
ans += val[temp];
|
||||
temp = f[temp];
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
};
|
||||
Trie ac, buf;
|
||||
void dfs(int u, int v){
|
||||
for(int i = 0;i < 2;i++){
|
||||
if( buf.ch[v][i] )
|
||||
{
|
||||
int e2 = buf.ch[v][i];
|
||||
if(! ac.ch[u][i])
|
||||
{
|
||||
memset(ac.ch[ac.sz], 0, sizeof(ac.ch[ac.sz]));
|
||||
ac.ch[u][i] = ac.sz++;
|
||||
}
|
||||
int e1 = ac.ch[u][i];
|
||||
ac.val[e1] |= buf.val[e2];
|
||||
dfs(e1, e2);
|
||||
}
|
||||
}
|
||||
}
|
||||
void join(){
|
||||
dfs(0, 0);
|
||||
buf.init();
|
||||
ac.getFail();
|
||||
}
|
||||
char s[6000000],temp[6000000];
|
||||
int main(){
|
||||
int Cas = 1, T, n;scanf("%d",&T);
|
||||
while(T--){
|
||||
scanf("%d",&n);
|
||||
printf("Case #%d:\n",Cas++);
|
||||
ac.init();
|
||||
buf.init();
|
||||
int L = 0;
|
||||
while(n--){
|
||||
scanf("%s",temp);
|
||||
int len = strlen ( temp + 1 ) ;
|
||||
s[0] = temp[0] ;
|
||||
for (int i = 0 ; i < len ; i ++ )
|
||||
s[i+1] = temp[1+(i+L%len+len)%len] ;
|
||||
s[len+1] = '\0';
|
||||
if(s[0] == '+'){
|
||||
if( buf.search(s+1) || ac.search(s+1) )continue;
|
||||
buf.insert(s+1);
|
||||
buf.getFail();
|
||||
if(buf.sz > 2000) join();
|
||||
}
|
||||
else
|
||||
{
|
||||
L = buf.find(s+1) + ac.find(s+1);
|
||||
printf("%d\n", L);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
int change(char s[])
|
||||
{
|
||||
if(strcmp(s,"B]") == 0)return 0;
|
||||
if(strcmp(s,"KB]") == 0)return 1;
|
||||
if(strcmp(s,"MB]") == 0)return 2;
|
||||
if(strcmp(s,"GB]") == 0)return 3;
|
||||
if(strcmp(s,"TB]") == 0)return 4;
|
||||
if(strcmp(s,"PB]") == 0)return 5;
|
||||
if(strcmp(s,"EB]") == 0)return 6;
|
||||
if(strcmp(s,"ZB]") == 0)return 7;
|
||||
if(strcmp(s,"YB]") == 0)return 8;
|
||||
}
|
||||
char s[100];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int iCase = 0;
|
||||
double a;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%lf[%s",&a,s);
|
||||
int t = change(s);
|
||||
double ans = pow(1000.0,t)/pow(1024.0,t);
|
||||
ans = 1-ans;
|
||||
printf("Case #%d: %.2lf%%\n",iCase,ans*100);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,223 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <set>
|
||||
using namespace std;
|
||||
#define eps 1e-8
|
||||
#define LL long long
|
||||
#define mod 1000000007
|
||||
#define mxn 50005
|
||||
int n, m, T, t, cnt;
|
||||
struct Team {
|
||||
string name;
|
||||
int solve, penalty;
|
||||
int ac_time[26];
|
||||
int submit_forzen[26];
|
||||
int submit_final[26];
|
||||
int submit_valid[26];
|
||||
bool ok_forzen[26];
|
||||
bool ok_final[26];
|
||||
int last[26];
|
||||
vector<int> pending;
|
||||
void init( string s ) {
|
||||
name = s;
|
||||
solve = penalty = 0;
|
||||
memset(submit_forzen, 0, m * 4);
|
||||
memset(submit_final, 0, m * 4);
|
||||
memset(submit_valid, 0, m * 4);
|
||||
memset(ok_forzen, 0, m);
|
||||
memset(ok_final, 0, m);
|
||||
memset(last, 0, m * 4);
|
||||
pending.clear();
|
||||
}
|
||||
bool operator < (const Team &b) const {
|
||||
if( solve > b.solve ) return true;
|
||||
if( solve < b.solve ) return false;
|
||||
if( penalty < b.penalty ) return true;
|
||||
if( penalty > b.penalty ) return false;
|
||||
for( int j = solve - 1; j >= 0; --j ) {
|
||||
if( last[j] < b.last[j] )
|
||||
return true;
|
||||
else if( last[j] > b.last[j] )
|
||||
return false;
|
||||
}
|
||||
return name > b.name;
|
||||
}
|
||||
void add( int id, int tim, int tp ) {
|
||||
if( ok_forzen[id] ) return ;
|
||||
if( ok_final[id] ) {
|
||||
if( tim < t ) return ;
|
||||
++submit_final[id];
|
||||
return ;
|
||||
}
|
||||
if( tp == 0 ) {
|
||||
if( tim < t ) {
|
||||
ok_forzen[id] = true;
|
||||
ac_time[id] = tim;
|
||||
penalty += ac_time[id] + submit_valid[id] * 20;
|
||||
int j = solve++;
|
||||
last[j] = tim;
|
||||
while( j > 0 && last[j] < last[j-1] )
|
||||
swap(last[j], last[j-1]), --j;
|
||||
}
|
||||
else {
|
||||
ok_final[id] = true;
|
||||
ac_time[id] = tim;
|
||||
++submit_final[id];
|
||||
}
|
||||
}
|
||||
else if( tp == 1 ) {
|
||||
if( tim < t ) {
|
||||
++submit_forzen[id];
|
||||
++submit_valid[id];
|
||||
}
|
||||
else {
|
||||
++submit_final[id];
|
||||
++submit_valid[id];
|
||||
}
|
||||
}
|
||||
else {
|
||||
if( tim < t ) return ;
|
||||
else {
|
||||
++submit_final[id];
|
||||
}
|
||||
}
|
||||
}
|
||||
void relax() {
|
||||
int id = pending.back();
|
||||
if( ok_final[id] ) {
|
||||
penalty += ac_time[id] + submit_valid[id] * 20;
|
||||
int j = solve++;
|
||||
last[j] = ac_time[id];
|
||||
while( j > 0 && last[j] < last[j-1] )
|
||||
swap(last[j], last[j-1]), --j;
|
||||
}
|
||||
pending.pop_back();
|
||||
}
|
||||
void forzen() {
|
||||
for( int i = m - 1; i >= 0; --i )
|
||||
if( submit_final[i] )
|
||||
pending.push_back(i);
|
||||
}
|
||||
}p[mxn];
|
||||
struct Submit {
|
||||
int team_id, problem_id, submit_time;
|
||||
int tp; //0: Yes 1: No 2: Errors
|
||||
bool operator < (const Submit &b) const {
|
||||
return submit_time < b.submit_time || submit_time == b.submit_time && tp > b.tp;
|
||||
}
|
||||
}Sub[mxn];
|
||||
struct Index {
|
||||
int id;
|
||||
Index(){}
|
||||
Index(int id):id(id) {}
|
||||
bool operator < (const Index &b) const {
|
||||
return p[id] < p[b.id];
|
||||
}
|
||||
}idx[mxn];
|
||||
map<string, int> mp;
|
||||
set<Index> st;
|
||||
void Forzen() {
|
||||
st.clear();
|
||||
for( int i = 1; i <= cnt; ++i )
|
||||
st.insert(Index(i));
|
||||
int rank = 0;
|
||||
for( set<Index>::iterator it = st.begin(); it != st.end(); ++it ) {
|
||||
Team &k = p[it->id];
|
||||
printf( "%s %d %d %d", k.name.c_str(), ++rank, k.solve, k.penalty );
|
||||
for( int i = 0; i < m; ++i ) {
|
||||
if( k.ok_forzen[i] ) {
|
||||
if( k.submit_valid[i] == 0 )
|
||||
printf( " +" );
|
||||
else printf( " +%d", k.submit_valid[i] );
|
||||
}
|
||||
else if( k.submit_final[i] ) {
|
||||
if( k.submit_forzen[i] == 0 )
|
||||
printf( " 0/%d", k.submit_final[i] );
|
||||
else printf( " -%d/%d", k.submit_forzen[i], k.submit_final[i] );
|
||||
}
|
||||
else if( k.submit_forzen[i] )
|
||||
printf( " -%d", k.submit_forzen[i] );
|
||||
else printf( " ." );
|
||||
}
|
||||
puts( "" );
|
||||
}
|
||||
}
|
||||
void Update() {
|
||||
for( int i = 1; i <= cnt; ++i )
|
||||
p[i].forzen();
|
||||
while( st.size() ) {
|
||||
set<Index>::iterator it = st.end();
|
||||
--it;
|
||||
Team &k = p[it->id];
|
||||
Index nxt = Index(it->id);
|
||||
st.erase(it);
|
||||
if( k.pending.size() == 0 ) continue;
|
||||
k.relax();
|
||||
set<Index>::iterator fit = st.upper_bound(nxt);
|
||||
if( fit != st.end() ) {
|
||||
printf( "%s %s %d %d\n", k.name.c_str(), p[fit->id].name.c_str(), k.solve, k.penalty );
|
||||
}
|
||||
st.insert(fit, nxt);
|
||||
}
|
||||
}
|
||||
void Final() {
|
||||
for( int i = 1; i <= cnt; ++i ) idx[i].id = i;
|
||||
sort(idx + 1, idx + cnt + 1);
|
||||
for( int j = 1; j <= cnt; ++j ) {
|
||||
Team &k = p[idx[j].id];
|
||||
printf( "%s %d %d %d", k.name.c_str(), j, k.solve, k.penalty );
|
||||
for( int i = 0; i < m; ++i ) {
|
||||
if( k.ok_forzen[i] || k.ok_final[i] ) {
|
||||
if( k.submit_valid[i] == 0 )
|
||||
printf( " +" );
|
||||
else printf( " +%d", k.submit_valid[i] );
|
||||
}
|
||||
else if( k.submit_valid[i] )
|
||||
printf( " -%d", k.submit_valid[i] );
|
||||
else printf( " ." );
|
||||
}
|
||||
puts( "" );
|
||||
}
|
||||
}
|
||||
int cal( char c ) {
|
||||
if( c == 'Y' ) return 0;
|
||||
if( c == 'N' ) return 1;
|
||||
return 2;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int tes, cas = 0, cur_time;
|
||||
char sname[50], pro[10], ret[10];
|
||||
scanf( "%d", &tes );
|
||||
while( tes-- ) {
|
||||
cnt = 0; mp.clear();
|
||||
scanf( "%d%d%d%d", &n, &m, &T, &t );
|
||||
for( int i = 0; i < n; ++i ) {
|
||||
scanf( "%s%s%d%s", sname, pro, &cur_time, ret );
|
||||
string s = sname;
|
||||
if( !mp.count(s) ) {
|
||||
mp[s] = ++cnt;
|
||||
p[cnt].init(s);
|
||||
Sub[i].team_id = cnt;
|
||||
}
|
||||
else Sub[i].team_id = mp[s];
|
||||
Sub[i].problem_id = pro[0] - 'A';
|
||||
Sub[i].submit_time = cur_time;
|
||||
Sub[i].tp = cal(ret[0]);
|
||||
}
|
||||
sort(Sub, Sub + n);
|
||||
for( int i = 0; i < n; ++i )
|
||||
p[Sub[i].team_id].add(Sub[i].problem_id, Sub[i].submit_time, Sub[i].tp);
|
||||
printf( "Case #%d:\n", ++cas );
|
||||
Forzen();
|
||||
Update();
|
||||
Final();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
long long gcd(long long a,long long b)
|
||||
{
|
||||
if(b == 0)return a;
|
||||
return gcd(b,a%b);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
long long a,b,c,d,p,m;
|
||||
int T;
|
||||
int iCase = 0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&d,&p,&m);
|
||||
long long ans = 0;
|
||||
if(b+c <= a+d)
|
||||
{
|
||||
long long t1 = (a+c)%p;
|
||||
long long add = (m - t1 + p)%p;
|
||||
long long cnt1 = (a+c + add-m)/p;
|
||||
long long t2 = (b+c-1)%p;
|
||||
long long sub = (t2 - m + p)%p;
|
||||
long long cnt2 = (b+c-1-sub-m)/p;
|
||||
ans += (cnt2 - cnt1 + 1)*(1+add) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2 * p;
|
||||
t1 = (b+c)%p;
|
||||
add = (m - t1 + p)%p;
|
||||
cnt1 = (b+c+add-m)/p;
|
||||
t2 = (a+d)%p;
|
||||
sub = (t2 - m + p)%p;
|
||||
cnt2 = (a+d-sub-m)/p;
|
||||
ans += (cnt2 - cnt1 + 1)*(b-a+1);
|
||||
t1 = (a+d+1)%p;
|
||||
add = (m - t1 + p)%p;
|
||||
cnt1 = (a+d+1+add-m)/p;
|
||||
t2 = (b+d)%p;
|
||||
sub = (t2 - m + p)%p;
|
||||
cnt2 = (b+d-sub-m)/p;
|
||||
ans += (cnt2 - cnt1 + 1)*(1+sub) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2*p;
|
||||
}
|
||||
else
|
||||
{
|
||||
long long t1 = (a+c)%p;
|
||||
long long add = (m - t1 + p)%p;
|
||||
long long cnt1 = (a+c + add-m)/p;
|
||||
long long t2 = (a+d-1)%p;
|
||||
long long sub = (t2 - m + p)%p;
|
||||
long long cnt2 = (a+d-1-sub-m)/p;
|
||||
ans += (cnt2 - cnt1 + 1)*(1+add) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2 * p;
|
||||
t1 = (a+d)%p;
|
||||
add = (m - t1 + p)%p;
|
||||
cnt1 = (a+d+add-m)/p;
|
||||
t2 = (b+ c)%p;
|
||||
sub = (t2 - m + p)%p;
|
||||
cnt2 = (b+c-sub-m)/p;
|
||||
ans += (cnt2 - cnt1 + 1)*(d-c+1);
|
||||
t1 = (b+c+1)%p;
|
||||
add = (m - t1 + p)%p;
|
||||
cnt1 = (b+c+1+add-m)/p;
|
||||
t2 = (b+d)%p;
|
||||
sub = (t2 - m + p)%p;
|
||||
cnt2 = (b+d - sub-m)/p;
|
||||
ans += (cnt2 - cnt1 + 1)*(1+sub) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2*p;
|
||||
}
|
||||
long long tot = (b-a+1)*(d-c+1);
|
||||
long long GCD = gcd(ans,tot);
|
||||
ans /= GCD;
|
||||
tot /= GCD;
|
||||
printf("Case #%d: %I64d/%I64d\n",iCase,ans,tot);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <map>
|
||||
#include <cstdlib>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <vector>
|
||||
#include <ctype.h>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <set>
|
||||
#define PI acos(-1.0)
|
||||
#define maxn 100005
|
||||
#define INF 0x7fffffff
|
||||
#define eps 1e-8
|
||||
typedef long long LL;
|
||||
typedef unsigned long long ULL;
|
||||
using namespace std;
|
||||
struct aa
|
||||
{
|
||||
LL p,s;
|
||||
LL cost;
|
||||
} a[100005];
|
||||
struct bb
|
||||
{
|
||||
LL i,q;
|
||||
LL cost;
|
||||
} b[100005];
|
||||
bool cmp1(bb a,bb b)
|
||||
{
|
||||
return a.i<b.i;
|
||||
}
|
||||
bool cmp2(bb a,bb b)
|
||||
{
|
||||
return a.q<b.q;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int m,n;
|
||||
scanf("%d%d",&m,&n);
|
||||
for(int i=0; i<m; i++)
|
||||
{
|
||||
scanf("%I64d%I64d",&a[i].p,&a[i].s);
|
||||
}
|
||||
a[m-1].cost=a[m-1].p*a[m-1].s;
|
||||
for(int i=m-2; i>=0; i--)
|
||||
a[i].cost=min(a[i+1].cost,a[i].p*a[i].s);
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
scanf("%I64d",&b[i].q);
|
||||
b[i].i=i;
|
||||
}
|
||||
sort(b,b+n,cmp2);
|
||||
int top1=0;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
while(b[i].q>=a[top1].p&&top1<m)
|
||||
top1++;
|
||||
if(top1==m)
|
||||
b[i].cost=b[i].q*a[top1-1].s;
|
||||
else
|
||||
b[i].cost=min(b[i].q*a[top1-1].s,a[top1].cost);
|
||||
}
|
||||
sort(b,b+n,cmp1);
|
||||
for(int i=0; i<n; i++)
|
||||
printf("%I64d\n",b[i].cost);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#define eps 1e-8
|
||||
using namespace std;
|
||||
#define N 10007
|
||||
int sgn(double x)
|
||||
{
|
||||
if(x > eps) return 1;
|
||||
if(x < -eps) return -1;
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double Rm,R,r,x,y,vx,vy;
|
||||
while(scanf("%lf%lf%lf%lf%lf%lf%lf",&Rm,&R,&r,&x,&y,&vx,&vy)!=EOF)
|
||||
{
|
||||
double A1 = (vx*vx+vy*vy);
|
||||
double B1 = (2*vx*x+2*y*vy);
|
||||
double C1 = x*x+y*y-(R+r)*(R+r);
|
||||
double A2 = A1;
|
||||
double B2 = B1;
|
||||
double C2 = x*x+y*y-(Rm+r)*(Rm+r);
|
||||
double delta1 = B1*B1 - 4.0*A1*C1;
|
||||
double delta2 = B2*B2 - 4.0*A2*C2;
|
||||
if(sgn(delta1) <= 0)
|
||||
{
|
||||
puts("0.000");
|
||||
continue;
|
||||
}
|
||||
double J11 = (-B1 + sqrt(delta1))/(2.0*A1);
|
||||
double J12 = (-B1 - sqrt(delta1))/(2.0*A1);
|
||||
if(sgn(J12) >= 0)
|
||||
{
|
||||
if(sgn(delta2) <= 0)
|
||||
{
|
||||
printf("%.3f\n",fabs(J11-J12));
|
||||
continue;
|
||||
}
|
||||
double J22 = (-B2 - sqrt(delta2))/(2.0*A2);
|
||||
printf("%.3f\n",(J22-J12)*2.0);
|
||||
}
|
||||
else
|
||||
puts("0.000");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <cstring>
|
||||
#include <stdio.h>
|
||||
#include <cmath>
|
||||
#include <math.h>
|
||||
#define rep(i,a,b) for(int i=(a);i<(b);++i)
|
||||
#define rrep(i,b,a) for(int i = (b); i >= (a); --i)
|
||||
#define clr(a,x) memset(a,(x),sizeof(a))
|
||||
#define LL unsigned long long
|
||||
#define eps 1e-8
|
||||
using namespace std;
|
||||
LL n;
|
||||
LL gcd(LL a, LL b)
|
||||
{
|
||||
while (a && b) {
|
||||
if (a > b) a %= b;
|
||||
else b %= a;
|
||||
}
|
||||
return a + b;
|
||||
}
|
||||
LL lcm(LL a,LL b)
|
||||
{
|
||||
return a * b / gcd(a,b);
|
||||
}
|
||||
void mul(LL A[2][2],LL B[2][2],LL ret[2][2],LL mod)
|
||||
{
|
||||
LL C[2][2] = { 0 };
|
||||
rep(i,0,2) rep(j,0,2) rep(k,0,2)
|
||||
C[i][j] = (C[i][j] + A[i][k] * B[k][j] % mod) % mod;
|
||||
rep(i,0,2) rep(j,0,2)
|
||||
ret[i][j] = C[i][j];
|
||||
}
|
||||
void qpow(LL base[2][2],LL p,LL dest[2][2],LL mod)
|
||||
{
|
||||
LL ret[2][2] = { 0 };
|
||||
ret[0][0] = ret[1][1] = 1;
|
||||
while (p > 0) {
|
||||
if (p & 1) mul(ret,base,ret,mod);
|
||||
mul(base,base,base,mod);
|
||||
p >>= 1;
|
||||
}
|
||||
rep(i,0,2) rep(j,0,2) dest[i][j] = ret[i][j];
|
||||
}
|
||||
LL qpow(LL base,LL p,LL mod)
|
||||
{
|
||||
LL ret = 1;
|
||||
while (p) {
|
||||
if (p & 1) ret = ret * base % mod;
|
||||
base = base * base % mod;
|
||||
p >>= 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
LL S[10000],c;
|
||||
LL f1,f2;
|
||||
void F(LL p,LL mod)
|
||||
{
|
||||
LL A[2][2] = { 0 };
|
||||
A[0][0] = 1; A[0][1] = 1;
|
||||
A[1][0] = 1; A[1][1] = 0;
|
||||
qpow(A,p-1,A,mod);
|
||||
f1 = (A[1][0]+A[1][1]) % mod; f2 = (A[0][0] + A[0][1]) % mod;
|
||||
}
|
||||
LL loop(LL mod)
|
||||
{
|
||||
if (mod == 2) return 3;
|
||||
else if (mod == 3) return 8;
|
||||
else if (mod == 5) return 20;
|
||||
LL p;
|
||||
if (qpow(5,(mod-1)>>1,mod) == 1) p = mod - 1;
|
||||
else p = 2*(mod + 1);
|
||||
c = 0;
|
||||
for(LL i = 1; i * i <= p; ++i) if (p % i == 0) {
|
||||
LL x = i , y = p / i;
|
||||
F(x,mod);
|
||||
if (f1 == 0 && f2 == 1) return x;
|
||||
if (y != x) S[c++] = y;
|
||||
}
|
||||
while (c > 0) {
|
||||
F(S[--c],mod);
|
||||
if (f1 == 0 && f2 == 1) return S[c];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (cin >> n) {
|
||||
LL x = n;
|
||||
LL ans = 1;
|
||||
for(LL i = 2; i * i <= x; ++i) if (x % i == 0) {
|
||||
LL len = loop(i);
|
||||
LL S = 1;
|
||||
do x /= i, S = S * i;
|
||||
while (x % i == 0);
|
||||
S /= i; S = S * len;
|
||||
ans = lcm(ans,S);
|
||||
}
|
||||
if (x > 1) {
|
||||
LL len = loop(x);
|
||||
ans = lcm(ans,len);
|
||||
}
|
||||
if (ans % 2 == 0) ans /= 2;
|
||||
printf("%I64u\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <cstring>
|
||||
#include <time.h>
|
||||
#include <stdio.h>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
#include <math.h>
|
||||
#include <map>
|
||||
#define rep(i,a,b) for(int i=(a);i<(b);++i)
|
||||
#define rrep(i,b,a) for(int i = (b); i >= (a); --i)
|
||||
#define clr(a,x) memset(a,(x),sizeof(a))
|
||||
#define LL long long
|
||||
#define eps 1e-10
|
||||
#define zero(x) -eps < (x) && (x) < eps
|
||||
using namespace std;
|
||||
short dp[2][1<<22];
|
||||
int q[2][1<<15];
|
||||
bool inq[2][1<<22];
|
||||
const int inf = 1<<14;
|
||||
char A[33][33];
|
||||
int N,M;
|
||||
inline int min(int a,int b) { return a < b ? a : b; }
|
||||
inline int max(int a,int b) { return a > b ? a : b; }
|
||||
inline int getBit(int s,int p)
|
||||
{
|
||||
return (s & (3 << (p << 1))) >> (p << 1);
|
||||
}
|
||||
inline void setBit(int & s,int p,int x)
|
||||
{
|
||||
s = (s ^ (s & (3 << (p<<1)))) | (x << (p<<1));
|
||||
}
|
||||
int cur;
|
||||
int rear[2];
|
||||
inline void update(int r,int c,int t,int cost)
|
||||
{
|
||||
if (dp[cur^1][t] > cost) dp[cur^1][t] = cost;
|
||||
if (!inq[cur^1][t]) inq[cur^1][t] = true, q[cur^1][rear[cur^1]++] = t;
|
||||
}
|
||||
inline void dp_block(int r,int c,int s)
|
||||
{
|
||||
int t, c1 = getBit(s,M), c2 = getBit(s,c);
|
||||
if (c1 || c2) return;
|
||||
if (A[r][c] == '#') {
|
||||
t = s;
|
||||
update(r,c,t,dp[cur][s]);
|
||||
return;
|
||||
}
|
||||
int side = 0;
|
||||
rep(j,0,c)
|
||||
if (getBit(s,j)) side ^= 1;
|
||||
if (side == 0 && A[r][c] == 'L') return;
|
||||
if (side == 1 && A[r][c] == 'W') return;
|
||||
t = s;
|
||||
update(r,c,t,dp[cur][s]);
|
||||
}
|
||||
inline void dp_digit(int r,int c,int s)
|
||||
{
|
||||
int t;
|
||||
int c1 = getBit(s,M);
|
||||
int c2 = getBit(s,c);
|
||||
if (c1 == 0 && c2 == 0) {
|
||||
t = s;
|
||||
update(r,c,t,dp[cur][s]);
|
||||
setBit(t,M,2); setBit(t,c,1);
|
||||
if (c < M-1) update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
} else if (c1 == 0 || c2 == 0) {
|
||||
int x = (c1 == 0 ? c2 : c1);
|
||||
t = s;
|
||||
setBit(t,M,x); setBit(t,c,0);
|
||||
if (c < M-1) update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
t = s;
|
||||
setBit(t,c,x); setBit(t,M,0);
|
||||
update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
} else if (c1 == c2) {
|
||||
int z = (c1 == 1 ? c : c-1);
|
||||
for(; 0 <= z && z < M; z += (c1 == 1 ? 1 : -1))
|
||||
if (getBit(s,z) == (c1 ^ 3)) break;
|
||||
if (0 <= z && z < M) {
|
||||
t = s;
|
||||
setBit(t,z,c1);
|
||||
setBit(t,M,0); setBit(t,c,0);
|
||||
update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
}
|
||||
} else if (c1 == 2 && c2 == 1) {
|
||||
t = s; setBit(t,M,0); setBit(t,c,0);
|
||||
update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
} else if (c1 == 3 && c2 == 1) {
|
||||
int z = c;
|
||||
for(; z < M; ++z)
|
||||
if (getBit(s,z) == 2) break;
|
||||
if (z < M) {
|
||||
t = s;
|
||||
setBit(t,c,0); setBit(t,M,0);
|
||||
setBit(t,z,3);
|
||||
update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
}
|
||||
} else if (c1 == 2 && c2 == 3) {
|
||||
int z = c-1;
|
||||
for(; z >= 0; --z)
|
||||
if (getBit(s,z) == 1) break;
|
||||
if (z >= 0) {
|
||||
t = s;
|
||||
setBit(t,c,0); setBit(t,M,0);
|
||||
setBit(t,z,3);
|
||||
update(r,c,t,dp[cur][s] + A[r][c] - '0');
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
cur = 0;
|
||||
rear[0] = rear[1] = 0;
|
||||
rep(i,0,(1<<((M+1)<<1))) dp[0][i] = dp[1][i] = inf;
|
||||
clr(inq,0);
|
||||
rep(i,0,M) {
|
||||
int s = 0;
|
||||
setBit(s,i,3);
|
||||
dp[cur][s] = 0;
|
||||
q[cur][rear[cur]++] = s;
|
||||
}
|
||||
rep(i,0,N) rep(j,0,M) {
|
||||
rep(k,0,rear[cur]) {
|
||||
int s = q[cur][k];
|
||||
if (isdigit(A[i][j])) dp_digit(i,j,s);
|
||||
else dp_block(i,j,s);
|
||||
inq[cur][s] = false;
|
||||
dp[cur][s] = inf;
|
||||
}
|
||||
rear[cur] = 0;
|
||||
cur ^= 1;
|
||||
}
|
||||
int ans = inf;
|
||||
int c = 0;
|
||||
rep(j,0,M) {
|
||||
int s = 0;
|
||||
setBit(s,j,3);
|
||||
ans = min(ans,dp[cur][s]);
|
||||
}
|
||||
if (ans == inf) ans = -1;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (scanf("%d%d",&N,&M)==2) {
|
||||
rep(i,0,N) scanf("%s",A[i]);
|
||||
int W = 0, L = 0;
|
||||
rep(i,0,N) rep(j,0,M)
|
||||
if (A[i][j] == 'W') ++W;
|
||||
else if (A[i][j] == 'L') ++L;
|
||||
solve();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const double pi=acos(-1);
|
||||
int R,r,H,t,S;
|
||||
double getlen(int n,double r)
|
||||
{
|
||||
return 2.0*r*tan(pi/n);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d%d%d%d",&R,&r,&H,&t,&S)!=EOF)
|
||||
{
|
||||
double h=(double)H/t,ans=0;
|
||||
int limit=100000;
|
||||
for(int i=t;i>=1;i--)
|
||||
{
|
||||
double rr=1.0*(R-r)/t*(i-1)+r;
|
||||
int mi=3,ma=limit,mid,num;
|
||||
double s;
|
||||
while(mi<=ma)
|
||||
{
|
||||
mid=(mi+ma)>>1;
|
||||
double tmp=getlen(mid,rr)*h;
|
||||
if(tmp-S>1e-8)
|
||||
{
|
||||
s=tmp;
|
||||
num=mid;
|
||||
mi=mid+1;
|
||||
}
|
||||
else
|
||||
ma=mid-1;
|
||||
}
|
||||
ans+=num*s;
|
||||
limit=num;
|
||||
}
|
||||
printf("%.3lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
#define maxn 50050
|
||||
int dp[maxn][2];
|
||||
int n,X,Y;
|
||||
bool state;
|
||||
int v[maxn],f,s[maxn],p;
|
||||
struct node{
|
||||
int t,nxt;
|
||||
}edge[maxn<<1];
|
||||
int head[maxn];
|
||||
bool vis[maxn];
|
||||
void solve(int u)
|
||||
{
|
||||
vis[u] = 1;
|
||||
if(s[u])state ^= 1;
|
||||
if(state)v[u] = -v[u];
|
||||
dp[u][0] = v[u];
|
||||
dp[u][1] = -v[u];
|
||||
for (int i = head[u]; i!=-1; i = edge[i].nxt)
|
||||
{
|
||||
int y = edge[i].t;
|
||||
if(!vis[y]){
|
||||
solve(y);
|
||||
dp[u][0] += max(dp[y][0],dp[y][1]-(s[y]?Y:X));
|
||||
dp[u][1] += max(dp[y][1],dp[y][0]-(s[y]?Y:X));
|
||||
}
|
||||
}
|
||||
if(s[u]) state ^= 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d%d",&n,&X,&Y)!=EOF)
|
||||
{
|
||||
memset(dp,0,sizeof(dp));
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(vis,0,sizeof(vis));
|
||||
int ind = 0;
|
||||
state = 0;
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%d%d%d%d",&v[i],&f,&s[i],&p);
|
||||
if(p) v[i] = -v[i];
|
||||
edge[ind].t = i;
|
||||
edge[ind].nxt = head[f];
|
||||
head[f] = ind++;
|
||||
}
|
||||
solve(0);
|
||||
if(dp[0][0] < 0)
|
||||
puts("HAHAHAOMG");
|
||||
else printf("%d\n",dp[0][0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue