KiritoTRw
GitHub
parent
c9791a72c9
commit
34d0415174
|
|
@ -0,0 +1,90 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define LL __int64
|
||||
struct corns {
|
||||
int q, p, n, m;
|
||||
}a[1111];
|
||||
int s[11] , ss[11], D, Y;
|
||||
LL ans , val[1002];
|
||||
void solve1(int i) {
|
||||
LL cur = Y;
|
||||
int day = 0, j;
|
||||
while(day <= D) {
|
||||
if(day + a[i].n <= D) {
|
||||
LL tot = cur/a[i].q;
|
||||
for(j = 9;j >= 1; j--) if(s[j]) {
|
||||
if(j*a[i].p > a[i].q) {
|
||||
if(tot <= s[j]) {
|
||||
cur += tot * (LL)( j*a[i].p - a[i].q );
|
||||
tot = 0;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
cur += (LL)s[j] * ( j*a[i].p - a[i].q );
|
||||
tot -= s[j];
|
||||
}
|
||||
}
|
||||
else break;
|
||||
}
|
||||
}
|
||||
day += a[i].n;
|
||||
}
|
||||
if(cur > ans) ans = cur;
|
||||
}
|
||||
void solve2(int i) {
|
||||
int j, k, l;
|
||||
memset(val, 0, sizeof(val));
|
||||
LL cur = Y;
|
||||
for(j = 1;j <= 9; j++) ss[j] = s[j];
|
||||
for(j= 0;j <= D; j++) {
|
||||
cur += val[j];
|
||||
LL tot = cur/a[i].q;
|
||||
for(k = 9;k >= 1; k--) if(ss[k]){
|
||||
int to = j+a[i].n;
|
||||
if(to > D) break;
|
||||
LL now = k*a[i].p;
|
||||
now += (LL)(D-to)/a[i].m * k*a[i].p;
|
||||
if(now > a[i].q) {
|
||||
LL get;
|
||||
if(tot > ss[k]) get = ss[k];
|
||||
else get = tot;
|
||||
ss[k] -= (int)get;
|
||||
tot -= get;
|
||||
cur -= get*a[i].q;
|
||||
val[to] += get * k *a[i].p;
|
||||
for(l = to+a[i].m;l <= D; l += a[i].m) val[l] += get *k * a[i].p;
|
||||
}
|
||||
else break;
|
||||
}
|
||||
}
|
||||
if(cur > ans) ans = cur;
|
||||
}
|
||||
int main() {
|
||||
int t, w, h, A, i;
|
||||
scanf("%d", &t);
|
||||
while(t--) {
|
||||
scanf("%d%d%d%d%d", &w, &h, &A, &D, &Y);
|
||||
memset(s, 0, sizeof(s));
|
||||
s[9] = (w/3) * (h/3);
|
||||
s[(w%3)*3] += h/3;
|
||||
s[(h%3)*3] += w/3;
|
||||
if((w%3) * (h%3) == 1) {
|
||||
s[5]++; s[3] -= 2; s[1] += 2;
|
||||
}
|
||||
else if((w%3) * (h%3) == 4) {
|
||||
s[8]++; s[6] -= 2; s[4] += 2;
|
||||
}
|
||||
else if((w%3)*(h%3) == 2) {
|
||||
s[7]++; s[6]--; s[3]--; s[2] += 2;
|
||||
}
|
||||
else s[(w%3)*(h%3)] ++;
|
||||
for(i =0;i < A; i++) scanf("%d%d%d%d", &a[i].q, &a[i].p, &a[i].n, &a[i].m);
|
||||
ans = Y;
|
||||
for(i = 0;i < A ; i++) {
|
||||
if(a[i].m == 0) solve1(i);
|
||||
else solve2(i);
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,179 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#define ll __int64
|
||||
using namespace std ;
|
||||
const int maxn = 211111 ;
|
||||
int c[26][maxn] , tot , dis[maxn] , pos[maxn] , rk[maxn] ;
|
||||
int tim[maxn] , dp[25][maxn] , cnt[maxn] , g[maxn] , line[maxn] , lon[maxn] ;
|
||||
ll val[maxn] , f[25] , pow26[maxn] ;
|
||||
const int mod = 1000000007 ;
|
||||
struct Edge
|
||||
{
|
||||
int to , next , v ;
|
||||
} edge[maxn<<1] ;
|
||||
int head[maxn] , E , n ;
|
||||
struct Point
|
||||
{
|
||||
int id ;
|
||||
int tim ;
|
||||
bool operator < ( const Point &t ) const
|
||||
{
|
||||
return tim < t.tim ;
|
||||
}
|
||||
} ;
|
||||
vector<Point> vec[maxn] ;
|
||||
void new_edge ( int a , int b , char *s )
|
||||
{
|
||||
edge[E].to = b ;
|
||||
edge[E].next = head[a] ;
|
||||
edge[E].v = s[0] - 'a' ;
|
||||
head[a] = E ++ ;
|
||||
edge[E].to = a ;
|
||||
edge[E].next = head[b] ;
|
||||
edge[E].v = s[0] - 'a' ;
|
||||
head[b] = E ++ ;
|
||||
}
|
||||
int new_node ()
|
||||
{
|
||||
int i ;
|
||||
for ( i = 0 ; i < 26 ; i ++ ) c[i][tot] = 0 ;
|
||||
val[tot] = 0 ;
|
||||
return tot ++ ;
|
||||
}
|
||||
int step ;
|
||||
void cal ( int u , int fa , int now )
|
||||
{
|
||||
int i ;
|
||||
Point fuck ;
|
||||
for ( i = head[u] ; i != -1 ; i = edge[i].next )
|
||||
{
|
||||
int v = edge[i].to ;
|
||||
if ( v == fa ) continue ;
|
||||
dis[v] = dis[u] + 1 ;
|
||||
tim[v] = ++ step ;
|
||||
fuck.id = v , fuck.tim = step ;
|
||||
vec[dis[v]].push_back ( fuck ) ;
|
||||
int k = edge[i].v ;
|
||||
if ( !c[k][now] )
|
||||
{
|
||||
c[k][now] = new_node () ;
|
||||
val[c[k][now]] = ( (ll) val[now] * 26 % mod + k ) % mod ;
|
||||
}
|
||||
pos[v] = c[k][now] ;
|
||||
cal ( v , u , c[k][now] ) ;
|
||||
lon[u] = max ( lon[u] , lon[v] ) ;
|
||||
cnt[u] += cnt[v] ;
|
||||
}
|
||||
lon[u] = max ( lon[u] , dis[u] ) ;
|
||||
cnt[u] ++ ;
|
||||
}
|
||||
void cal1 ( int now )
|
||||
{
|
||||
rk[now] = step ++ ;
|
||||
g[rk[now]] = now ;
|
||||
int i ;
|
||||
for ( i = 0 ; i < 26 ; i ++ )
|
||||
if ( c[i][now] )
|
||||
cal1 ( c[i][now] ) ;
|
||||
}
|
||||
int dep ;
|
||||
void init ()
|
||||
{
|
||||
for ( int i = 0 ; i <= n ; i ++ )
|
||||
{
|
||||
head[i] = -1 , vec[i].clear () ;
|
||||
lon[i] = dis[i] = rk[i] = cnt[i] = 0 ;
|
||||
}
|
||||
tot = E = 0 ;
|
||||
new_node () ;
|
||||
}
|
||||
int T ;
|
||||
void rmq ()
|
||||
{
|
||||
int i , j ;
|
||||
T = 0 ;
|
||||
for ( i = 1 ; i <= n ; i ++ )
|
||||
{
|
||||
int l = vec[i].size () ;
|
||||
if ( l == 0 ) break ;
|
||||
line[i] = T + 1 ;
|
||||
for ( j = 0 ; j < l ; j ++ )
|
||||
dp[0][++T] = rk[pos[vec[i][j].id]] ;
|
||||
}
|
||||
for ( i = 1 ; f[i] <= T ; i ++ )
|
||||
for ( j = 1 ; j + f[i] - 1 <= T ; j ++ )
|
||||
dp[i][j] = max ( dp[i-1][j] , dp[i-1][j+f[i-1]] ) ;
|
||||
}
|
||||
int query ( int l , int r )
|
||||
{
|
||||
if ( l == r ) return dp[0][l] ;
|
||||
if ( l > r ) swap ( l , r ) ;
|
||||
int i , j , k ;
|
||||
for ( i = 0 ; i <= 22 ; i ++ )
|
||||
if ( f[i] >= ( r - l + 1 ) )
|
||||
{
|
||||
k = i - 1 ;
|
||||
break ;
|
||||
}
|
||||
return max ( dp[k][l] , dp[k][r-f[k]+1] ) ;
|
||||
}
|
||||
char s[111] ;
|
||||
int main ()
|
||||
{
|
||||
int cas , i , j , a , b , q ;
|
||||
f[0] = pow26[0] = 1 ;
|
||||
for ( i = 1 ; i <= 22 ; i ++ )
|
||||
f[i] = (ll) f[i-1] * 2 % mod ;
|
||||
for ( i = 1 ; i < 100005 ; i ++ )
|
||||
pow26[i] = (ll) pow26[i-1] * 26 % mod ;
|
||||
scanf ( "%d" , &cas ) ;
|
||||
while ( cas -- )
|
||||
{
|
||||
scanf ( "%d" , &n ) ;
|
||||
init () ;
|
||||
for ( i = 1 ; i < n ; i ++ )
|
||||
{
|
||||
scanf ( "%d%d%s" , &a , &b , s ) ;
|
||||
new_edge ( a , b , s ) ;
|
||||
}
|
||||
step = 0 ;
|
||||
cal ( 1 , 0 , 0 ) ;
|
||||
step = 0 ;
|
||||
cal1 ( 0 ) ;
|
||||
rmq () ;
|
||||
pos[1] = 0 ;
|
||||
scanf ( "%d" , &q ) ;
|
||||
while ( q -- )
|
||||
{
|
||||
int u , m ;
|
||||
scanf ( "%d%d" , &u , &m ) ;
|
||||
if ( m == 0 )
|
||||
{
|
||||
puts ( "0" ) ;
|
||||
continue ;
|
||||
}
|
||||
if ( dis[u] + m > lon[u] )
|
||||
{
|
||||
puts ( "IMPOSSIBLE" ) ;
|
||||
continue ;
|
||||
}
|
||||
int dep = dis[u] + m ;
|
||||
Point fuck ;
|
||||
fuck.tim = tim[u] ;
|
||||
int l = lower_bound ( vec[dep].begin () , vec[dep].end () , fuck ) - vec[dep].begin () ;
|
||||
if ( l == vec[dep].size () ) l -- ;
|
||||
l += line[dep] ;
|
||||
fuck.tim = tim[u] + cnt[u] - 1 ;
|
||||
int r = upper_bound ( vec[dep].begin () , vec[dep].end () , fuck ) - vec[dep].begin () ;
|
||||
r -- ;
|
||||
r += line[dep] ;
|
||||
int k = query ( l , r ) ;
|
||||
k = g[k] ;
|
||||
u = pos[u] ;
|
||||
printf ( "%I64d\n" , ( val[k] - val[u] * pow26[m] % mod + mod ) % mod ) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int mod=1000000007;
|
||||
struct Matrix{
|
||||
long long arr[2][2];
|
||||
};
|
||||
Matrix init,unit;
|
||||
int n,k;
|
||||
long long num[2][2]={{4,-4},{1,0}};
|
||||
void Init(){
|
||||
for(int i=0;i<2;i++)
|
||||
for(int j=0;j<2;j++){
|
||||
init.arr[i][j]=num[i][j];
|
||||
unit.arr[i][j]=(i==j)?1:0;
|
||||
}
|
||||
}
|
||||
Matrix Mul(Matrix a,Matrix b){
|
||||
Matrix c;
|
||||
for(int i=0;i<2;i++)
|
||||
for(int j=0;j<2;j++){
|
||||
c.arr[i][j]=0;
|
||||
for(int k=0;k<2;k++)
|
||||
c.arr[i][j]=(c.arr[i][j]%mod+a.arr[i][k]*b.arr[k][j]%mod+mod)%mod;
|
||||
c.arr[i][j]%=mod;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
Matrix Pow(Matrix a,Matrix b,int k){
|
||||
while(k){
|
||||
if(k&1){
|
||||
b=Mul(a,b);
|
||||
}
|
||||
a=Mul(a,a);
|
||||
k>>=1;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d%d",&n,&k);
|
||||
Init();
|
||||
if(k>n){
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
int tmp=n-k+1;
|
||||
if(tmp==1){
|
||||
printf("1\n");
|
||||
continue;
|
||||
}
|
||||
if(tmp==2){
|
||||
printf("2\n");
|
||||
continue;
|
||||
}
|
||||
if(tmp==3){
|
||||
printf("5\n");
|
||||
continue;
|
||||
}
|
||||
Matrix res=Pow(init,unit,tmp-3);
|
||||
long long ans=(res.arr[0][0]*5+res.arr[0][1]*2)%mod;
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,370 @@
|
|||
#pragma comment(linker, "/STACK:102400000,102400000")
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<string>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<cmath>
|
||||
#include<cassert>
|
||||
#include<cstring>
|
||||
#include<iomanip>
|
||||
#include<ctime>
|
||||
using namespace std;
|
||||
#ifdef _WIN32
|
||||
typedef __int64 i64;
|
||||
#define out64 "%I64d\n"
|
||||
#define in64 "%I64d"
|
||||
#else
|
||||
typedef long long i64;
|
||||
#define out64 "%lld\n"
|
||||
#define in64 "%lld"
|
||||
#endif
|
||||
#define foreach(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
|
||||
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
|
||||
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
|
||||
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
|
||||
#define S64(a) scanf(in64,&a)
|
||||
#define SS(a) scanf("%d",&a)
|
||||
#define LL(a) ((a)<<1)
|
||||
#define RR(a) (((a)<<1)+1)
|
||||
#define pb push_back
|
||||
#define pf push_front
|
||||
#define X first
|
||||
#define Y second
|
||||
#define CL(Q) while(!Q.empty())Q.pop()
|
||||
#define MM(name,what) memset(name,what,sizeof(name))
|
||||
#define MC(a,b) memcpy(a,b,sizeof(b))
|
||||
#define MAX(a,b) ((a)>(b)?(a):(b))
|
||||
#define MIN(a,b) ((a)<(b)?(a):(b))
|
||||
const int inf = 0x3f3f3f3f;
|
||||
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;
|
||||
const double oo = 10e9;
|
||||
const double eps = 10e-9;
|
||||
const double pi = acos(-1.0);
|
||||
const int maxn = 100111;
|
||||
const int maxlevel = 21;
|
||||
struct Node
|
||||
{
|
||||
int now;
|
||||
int to;
|
||||
int c;
|
||||
int tot;
|
||||
int ss;
|
||||
const bool operator < (const Node& cmp) const {
|
||||
return tot > cmp.tot;
|
||||
}
|
||||
};
|
||||
int all;
|
||||
int n, m;
|
||||
vector<Node>g[maxn];
|
||||
int t[maxn];
|
||||
int dep[maxn];
|
||||
int df;
|
||||
int dfn[maxn];
|
||||
int dfv[maxn * 2];
|
||||
int st[maxn * 2][maxlevel];
|
||||
int up[maxn][maxlevel];
|
||||
int dp[maxn]; //down sum
|
||||
int xtof[maxn];
|
||||
int ftox[maxn];
|
||||
int vis[maxn];
|
||||
int lg2[maxn*2];
|
||||
void dfs(int now)
|
||||
{
|
||||
vis[now] = true;
|
||||
int to;
|
||||
for (int i = 0; i < (int)g[now].size(); i++) {
|
||||
to = g[now][i].to;
|
||||
if (!vis[to]) {
|
||||
t[to] = now;
|
||||
dfs(to);
|
||||
}
|
||||
}
|
||||
}
|
||||
int treedp(int now)
|
||||
{
|
||||
int to,id;
|
||||
dp[now] = 0;
|
||||
for (int i = 0; i < (int)g[now].size(); i++) {
|
||||
to = g[now][i].to;
|
||||
if (to != t[now]) {
|
||||
int temp = treedp(to) + g[now][i].c;
|
||||
g[now][i].tot = temp;
|
||||
dp[now] += temp;
|
||||
}
|
||||
else {
|
||||
id = i;
|
||||
}
|
||||
}
|
||||
if (t[now] != -1) {
|
||||
g[now][id].tot = all - dp[now];
|
||||
}
|
||||
return dp[now];
|
||||
}
|
||||
void euler_circuit(int now ,int step)
|
||||
{
|
||||
dep[now] = step;
|
||||
dfn[now] = df;
|
||||
dfv[df++] = now;
|
||||
int to;
|
||||
for (int i = 0; i < (int)g[now].size(); i++) {
|
||||
to = g[now][i].to;
|
||||
if (to != t[now]) {
|
||||
euler_circuit(to,step+1);
|
||||
dfv[df++] = now;
|
||||
}
|
||||
}
|
||||
}
|
||||
void get_up_node()
|
||||
{
|
||||
for (int i = 1; i <= n; i++) {
|
||||
up[i][0] = t[i];
|
||||
}
|
||||
int to;
|
||||
for (int step = 1; step < maxlevel; step++) {
|
||||
for (int now = 1; now <= n; now++) {
|
||||
to = up[now][step - 1];
|
||||
if (to == -1) {
|
||||
up[now][step] = -1;
|
||||
}
|
||||
else {
|
||||
up[now][step] = up[to][step - 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void sparse_table()
|
||||
{
|
||||
for (int i = 1; i < df; i++){
|
||||
st[i][0] = dep[dfv[i]];
|
||||
}
|
||||
int to;
|
||||
for (int step = 1; step <= lg2[n] + 1; step++){
|
||||
for (int now = 1; now < df; now++) {
|
||||
to = now + (1 << (step - 1));
|
||||
if (to < df){
|
||||
st[now][step] = min(st[now][step - 1], st[to][step - 1]);
|
||||
}
|
||||
else{
|
||||
st[now][step] = st[now][step - 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void relation()
|
||||
{
|
||||
int to;
|
||||
for (int now = 1; now <= n; now++){
|
||||
for (int i = 0; i < (int)g[now].size(); i++){
|
||||
to = g[now][i].to;
|
||||
if (to == t[now]){
|
||||
xtof[now] = i;
|
||||
}
|
||||
else{
|
||||
ftox[to] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int rmq(int l,int r)
|
||||
{
|
||||
return min(st[l][lg2[r - l]], st[r - (1 << lg2[r - l])][lg2[r - l]] );
|
||||
}
|
||||
int calculate(int x,bool first,int id1,int id2=-1)
|
||||
{
|
||||
if (id2 != -1){
|
||||
if (id1 > id2){
|
||||
swap(id1, id2);
|
||||
}
|
||||
}
|
||||
int sum = g[x][0].ss;
|
||||
sum -= g[x][id1].tot;
|
||||
if (id2 != -1){
|
||||
sum -= g[x][id2].tot;
|
||||
}
|
||||
int size = (int)g[x].size() - 1;
|
||||
if (size >= 1){
|
||||
sum += g[x][1].ss;
|
||||
}
|
||||
int ans = g[x][0].ss;
|
||||
if (id1 % 2 ){
|
||||
if (id1 + 1 <= size){
|
||||
ans -= g[x][id1 + 1].ss;
|
||||
if (id1 + 2 <= size){
|
||||
ans += g[x][id1 + 2].ss;
|
||||
}
|
||||
}
|
||||
if (id2 != -1){
|
||||
if (id2 % 2){
|
||||
ans -= g[x][id2].ss;
|
||||
if (id2 + 1 <= size){
|
||||
ans += g[x][id2 + 1].ss;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if (id2 + 1 <= size){
|
||||
ans -= g[x][id2 + 1].ss;
|
||||
if (id2 + 2 <= size){
|
||||
ans += g[x][id2 + 2].ss;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else{
|
||||
ans -= g[x][id1].ss;
|
||||
if (id1 + 1 <= size){
|
||||
ans += g[x][id1 + 1].ss;
|
||||
}
|
||||
if (id2 != -1){
|
||||
if (id2 % 2){
|
||||
ans -= g[x][id2].ss;
|
||||
if (id2 + 1 <= size){
|
||||
ans += g[x][id2 + 1].ss;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if (id2 + 1 <= size){
|
||||
ans -= g[x][id2 + 1].ss;
|
||||
if (id2 + 2 <= size){
|
||||
ans += g[x][id2 + 2].ss;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (first) return ans;
|
||||
else return sum - ans;
|
||||
}
|
||||
int go_up(int now, int x)
|
||||
{
|
||||
int step = 0;
|
||||
while (x) {
|
||||
if (x & 1) {
|
||||
now = up[now][step];
|
||||
}
|
||||
step++;
|
||||
x >>= 1;
|
||||
}
|
||||
return now;
|
||||
}
|
||||
int find(int a,int b)
|
||||
{
|
||||
int l = dfn[a];
|
||||
int r = dfn[b];
|
||||
if (l == r){
|
||||
return g[a][0].ss;
|
||||
}
|
||||
if (l > r){
|
||||
swap(l, r);
|
||||
}
|
||||
int lca = rmq(l, r + 1);
|
||||
if (dep[a] - lca + dep[b] - lca == 1){
|
||||
if (dep[a] == lca){
|
||||
return g[b][xtof[b]].tot + calculate(b, false, xtof[b]);
|
||||
}
|
||||
else if (dep[b] == lca){
|
||||
return g[b][ftox[a]].tot + calculate(b, false, ftox[a]);
|
||||
}
|
||||
}
|
||||
else if (dep[a] > dep[b]+1){
|
||||
int temp = dep[a] - dep[b];
|
||||
int mid = lca + temp / 2;
|
||||
int child = go_up(a, dep[a] - mid - 1);
|
||||
if (temp % 2){
|
||||
return g[t[child]][ftox[child]].tot + calculate(t[child], false, ftox[child], xtof[t[child]]);
|
||||
}
|
||||
else{
|
||||
return g[t[child]][ftox[child]].tot + calculate(t[child], true, ftox[child], xtof[t[child]]);
|
||||
}
|
||||
}
|
||||
else if (dep[a] == dep[b] + 1) {
|
||||
int ca = go_up(a, dep[a] - lca - 1);
|
||||
int cb = go_up(b, dep[b] - lca - 1);
|
||||
int meet = t[ca];
|
||||
return g[meet][ftox[ca]].tot + calculate(meet, false, ftox[ca], ftox[cb]);
|
||||
}
|
||||
else if (dep[a] < dep[b]){
|
||||
int temp = dep[b] - dep[a];
|
||||
int mid = lca + (temp + 1)/ 2;
|
||||
int child = go_up(b, dep[b] - mid - 1);
|
||||
if (temp % 2){
|
||||
return g[t[child]][xtof[t[child]]].tot + calculate(t[child], false, xtof[t[child]], ftox[child]);
|
||||
}
|
||||
else{
|
||||
return g[t[child]][xtof[t[child]]].tot + calculate(t[child], true, xtof[t[child]], ftox[child]);
|
||||
}
|
||||
}
|
||||
else if(dep[a] == dep[b]) {
|
||||
int ca = go_up(a, dep[a] - lca - 1);
|
||||
int cb = go_up(b, dep[b] - lca - 1);
|
||||
int meet = t[ca];
|
||||
return g[meet][ftox[ca]].tot + calculate(meet, true, ftox[ca], ftox[cb]);
|
||||
}
|
||||
assert(false);
|
||||
}
|
||||
void start()
|
||||
{
|
||||
for (int i = 1; i <= n; i++) {
|
||||
vis[i] = false;
|
||||
}
|
||||
t[0] = t[1] = -1;
|
||||
dfs(1);
|
||||
treedp(1);
|
||||
for (int now = 1; now <= n; now++) {
|
||||
sort(g[now].begin(), g[now].end());
|
||||
for (int i =(int) g[now].size() - 1; i >= 0; i--) {
|
||||
g[now][i].ss = g[now][i].tot;
|
||||
if (i + 3 <= (int)g[now].size()) {
|
||||
g[now][i].ss += g[now][i + 2].ss;
|
||||
}
|
||||
}
|
||||
}
|
||||
df = 1;
|
||||
euler_circuit(1, 0);
|
||||
get_up_node();
|
||||
sparse_table();
|
||||
relation();
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for (int i = 0; i < maxlevel; i++){
|
||||
if ( (1<<i) < maxn*2)
|
||||
lg2[1 << i] = i;
|
||||
}
|
||||
for (int i = 3; i < maxn*2; i++) {
|
||||
if (!lg2[i]){
|
||||
lg2[i] = lg2[i - 1];
|
||||
}
|
||||
}
|
||||
int T;
|
||||
cin >> T;
|
||||
while (T--) {
|
||||
all = 0;
|
||||
cin >> n >> m;
|
||||
for (int i = 0; i <= n; i++){
|
||||
g[i].clear();
|
||||
}
|
||||
Node node;
|
||||
for (int i = 1; i <= n - 1; i++) {
|
||||
SS(node.now);
|
||||
SS(node.to);
|
||||
SS(node.c);
|
||||
g[node.now].push_back(node);
|
||||
swap(node.now, node.to);
|
||||
g[node.now].push_back(node);
|
||||
all += node.c;
|
||||
}
|
||||
start();
|
||||
int a, b;
|
||||
for (int i = 1; i <= m; i++){
|
||||
SS(a); SS(b);
|
||||
printf("%d\n", find(a, b));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#define MAXM 111111
|
||||
#define MAXN 111111
|
||||
#define INF 1000000007
|
||||
#define eps 1e-8
|
||||
using namespace std;
|
||||
typedef vector<int>::iterator Viter;
|
||||
int n;
|
||||
vector<int>g;
|
||||
int a[MAXN];
|
||||
int dp1[MAXN], dp2[MAXN], num1[MAXN], num2[MAXN];
|
||||
void gao(int dp[], int num[])
|
||||
{
|
||||
g.clear();
|
||||
Viter it;
|
||||
for(int i = n - 1; i >= 0; i--)
|
||||
{
|
||||
int sz = g.size();
|
||||
if(!sz || a[i] >= g[sz - 1])
|
||||
{
|
||||
g.push_back(a[i]);
|
||||
dp[i] = sz + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
it = upper_bound(g.begin(), g.end(), a[i]);
|
||||
dp[i] = it - g.begin() + 1;
|
||||
*it = a[i];
|
||||
}
|
||||
pair<Viter, Viter>bounds = equal_range(g.begin(), g.end(), a[i]);
|
||||
num[i] = bounds.second - bounds.first;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d", &n);
|
||||
for(int i = 0; i < n; i++) scanf("%d", &a[i]);
|
||||
gao(dp1, num1);
|
||||
for(int i = 0; i < n; i++) a[i] = -a[i];
|
||||
gao(dp2, num2);
|
||||
int ans = 0;
|
||||
for(int i = 0; i < n; i++)
|
||||
ans = max(ans, dp1[i] + dp2[i] - min(num1[i], num2[i]));
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
#define maxn 100005
|
||||
struct list
|
||||
{
|
||||
int l,r;
|
||||
int w;
|
||||
}node[maxn];
|
||||
int fs[maxn*2];
|
||||
int fss[maxn*2];
|
||||
struct qq
|
||||
{
|
||||
int x;
|
||||
int id;
|
||||
}xx;
|
||||
vector<qq>num[maxn];
|
||||
int ans[maxn][2];
|
||||
int sum[maxn][2];
|
||||
int w[maxn];
|
||||
int n,m,q,len;
|
||||
int lowbit(int x)
|
||||
{
|
||||
return (x&(-x));
|
||||
}
|
||||
int search(int l,int r,int w)
|
||||
{
|
||||
while(l<r)
|
||||
{
|
||||
int mid=(l+r)/2;
|
||||
if(fs[mid]==w)return mid;
|
||||
if(fs[mid]<w)l=mid+1;
|
||||
else r=mid;
|
||||
}
|
||||
}
|
||||
void add(int x,int bs,int num)
|
||||
{
|
||||
for(;x<len;x+=lowbit(x))
|
||||
{
|
||||
sum[x][bs]+=num;
|
||||
}
|
||||
}
|
||||
int allsum(int s,int bs)
|
||||
{
|
||||
int ss;
|
||||
ss=0;
|
||||
while(s>0)
|
||||
{
|
||||
ss+=sum[s][bs];
|
||||
s=s-lowbit(s);
|
||||
}
|
||||
return ss;
|
||||
}
|
||||
void dfs(int x)
|
||||
{
|
||||
int s;
|
||||
s=num[x].size();
|
||||
for(int i=0;i<s;i++)
|
||||
{
|
||||
xx=num[x][i];
|
||||
int z,id;
|
||||
z=search(1,len,xx.x);
|
||||
id=xx.id;
|
||||
if(allsum(z,0)-allsum(z-1,0)+allsum(z,1)-allsum(z-1,1)>0)
|
||||
{
|
||||
ans[id][0]=-1;
|
||||
continue;
|
||||
}
|
||||
int ll,lr,rl,rr;
|
||||
ll=allsum(len-1,0)-allsum(z,0);
|
||||
rl=allsum(z,0);
|
||||
lr=allsum(len-1,1)-allsum(z,1);
|
||||
rr=allsum(z,1);
|
||||
ans[id][0]=rr;
|
||||
ans[id][1]=(rl+rr)*3+ll+lr;
|
||||
}
|
||||
s=search(1,len,node[x].w);
|
||||
if(node[x].l!=-1)
|
||||
{
|
||||
add(s,0,1);
|
||||
dfs(node[x].l);
|
||||
add(s,0,-1);
|
||||
}
|
||||
if(node[x].r!=-1)
|
||||
{
|
||||
add(s,1,1);
|
||||
dfs(node[x].r);
|
||||
add(s,1,-1);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,a,b,c,i;
|
||||
cin>>T;
|
||||
while(T--)
|
||||
{
|
||||
cin>>n;
|
||||
int ll=1;
|
||||
memset(fs,0,sizeof(fs));
|
||||
memset(ans,0,sizeof(ans));
|
||||
memset(fss,0,sizeof(fss));
|
||||
for (i = 1; i <= n; ++i) node[i].l = node[i].r = node[i].w = -1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
num[i].clear();
|
||||
scanf("%d",&w[i]);
|
||||
node[i].w=w[i];
|
||||
fss[ll++]=w[i];
|
||||
}
|
||||
cin>>m;
|
||||
for(i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
node[a].l=b;
|
||||
node[a].r=c;
|
||||
}
|
||||
cin>>q;
|
||||
for(i=1;i<=q;i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
fss[ll++]=b;
|
||||
xx.id=i;
|
||||
xx.x=b;
|
||||
num[a].push_back(xx);
|
||||
}
|
||||
len=1;
|
||||
sort(fss,fss+ll);
|
||||
for(i=1;i<ll;i++)
|
||||
if(fss[i]!=fss[i-1])fs[len++]=fss[i];
|
||||
dfs(1);
|
||||
for(i=1;i<=q;i++)
|
||||
{
|
||||
if(ans[i][0]==-1)printf("0\n");
|
||||
else printf("%d %d\n",ans[i][0],ans[i][1]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,191 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const double eps = 1e-6;
|
||||
int sgn(double x)
|
||||
{
|
||||
if(fabs(x) < eps)return 0;
|
||||
if(x < 0)return -1;
|
||||
else return 1;
|
||||
}
|
||||
struct Point
|
||||
{
|
||||
double x,y;
|
||||
Point(double _x = 0,double _y = 0)
|
||||
{
|
||||
x = _x; y = _y;
|
||||
}
|
||||
Point operator -(const Point &b)const
|
||||
{
|
||||
return Point(x-b.x,y-b.y);
|
||||
}
|
||||
double operator ^(const Point &b)const
|
||||
{
|
||||
return x*b.y - y*b.x;
|
||||
}
|
||||
double operator *(const Point &b)const
|
||||
{
|
||||
return x*b.x + y*b.y;
|
||||
}
|
||||
void input()
|
||||
{
|
||||
scanf("%lf%lf",&x,&y);
|
||||
}
|
||||
};
|
||||
struct Line
|
||||
{
|
||||
Point s,e;
|
||||
Line(){}
|
||||
Line(Point _s,Point _e)
|
||||
{
|
||||
s = _s; e = _e;
|
||||
}
|
||||
void input()
|
||||
{
|
||||
s.input();
|
||||
e.input();
|
||||
}
|
||||
};
|
||||
double dist(Point a,Point b)
|
||||
{
|
||||
return sqrt((a-b)*(a-b));
|
||||
}
|
||||
bool inter(Line l1,Line l2)
|
||||
{
|
||||
return
|
||||
sgn((l2.s-l1.e)^(l1.s-l1.e))*sgn((l2.e-l1.e)^(l1.s-l1.e)) < 0 &&
|
||||
sgn((l1.s-l2.e)^(l2.s-l2.e))*sgn((l1.e-l2.e)^(l2.s-l2.e)) < 0;
|
||||
}
|
||||
const int MAXN = 440;
|
||||
Point p[MAXN];
|
||||
Line line[MAXN];
|
||||
const double INF = 100000000.0;
|
||||
double dis[MAXN][MAXN];
|
||||
int n,m,P;
|
||||
int b[MAXN];
|
||||
int uN,vN;
|
||||
struct Edge
|
||||
{
|
||||
int to,next;
|
||||
}edge[MAXN*MAXN];
|
||||
int head[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));
|
||||
}
|
||||
int linker[MAXN];
|
||||
bool used[MAXN];
|
||||
bool dfs(int u)
|
||||
{
|
||||
for(int i = head[u]; i!= -1;i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].to;
|
||||
if(!used[v])
|
||||
{
|
||||
used[v] = true;
|
||||
if(linker[v]==-1 || dfs(linker[v]))
|
||||
{
|
||||
linker[v] = u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int hungary()
|
||||
{
|
||||
int res = 0;
|
||||
memset(linker,-1,sizeof(linker));
|
||||
for(int u = 0;u < uN;u ++)
|
||||
{
|
||||
memset(used,false,sizeof(used));
|
||||
if(dfs(u))res++;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
bool check(double d)
|
||||
{
|
||||
uN = vN = n;
|
||||
init();
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = i+1;j < n;j++)
|
||||
if(dis[b[i]][b[j]] < d + eps)
|
||||
addedge(b[i],b[j]);
|
||||
if(n - hungary() <= P)return true;
|
||||
else return false;
|
||||
}
|
||||
double solve()
|
||||
{
|
||||
double l = 0, r = 100000.0;
|
||||
double ans;
|
||||
while(r-l >= eps)
|
||||
{
|
||||
double mid = (l+r)/2;
|
||||
if(check(mid))
|
||||
{
|
||||
ans = mid;
|
||||
r = mid - eps;
|
||||
}
|
||||
else l = mid + eps;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&P);
|
||||
for(int i = 0;i < n;i++)
|
||||
p[i].input();
|
||||
int t = n;
|
||||
for(int i = 0;i < m;i++)
|
||||
{
|
||||
line[i].input();
|
||||
p[n+2*i] = line[i].s;
|
||||
p[n+2*i+1] = line[i].e;
|
||||
}
|
||||
for(int i = 0;i < n+2*m;i++)
|
||||
for(int j = 0;j < n+2*m;j++)
|
||||
{
|
||||
if(i == j)
|
||||
{
|
||||
dis[i][j] = 0;
|
||||
continue;
|
||||
}
|
||||
bool flag = false;
|
||||
for(int k = 0;k < m;k++)
|
||||
if(inter(line[k],Line(p[i],p[j])))
|
||||
{
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
if(flag)dis[i][j] = 1e20;
|
||||
else dis[i][j] = dist(p[i],p[j]);
|
||||
}
|
||||
for(int k = 0;k < n+2*m;k++)
|
||||
for(int i = 0;i < n+2*m;i++)
|
||||
for(int j = 0;j < n+2*m;j++)
|
||||
dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
scanf("%d",&b[i]);
|
||||
b[i]--;
|
||||
}
|
||||
printf("%.2lf\n",solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
const int N=200010;
|
||||
int head[N],to[N],ne[N],w[N];
|
||||
int dis[N],que[N];
|
||||
bool vis[N];
|
||||
int edge,m,n;
|
||||
void init()
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
edge=0;
|
||||
}
|
||||
void add(int u,int v,int c)
|
||||
{
|
||||
to[edge]=v,w[edge]=c,ne[edge]=head[u],head[u]=edge++;
|
||||
to[edge]=u,w[edge]=c,ne[edge]=head[v],head[v]=edge++;
|
||||
}
|
||||
void bfs(int s)
|
||||
{
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(dis,0,sizeof(dis));
|
||||
int l,r,v,u;
|
||||
l=r=0;
|
||||
vis[s]=1;
|
||||
dis[s]=0;
|
||||
que[r++]=s;
|
||||
while(r>l)
|
||||
{
|
||||
u=que[l++];
|
||||
for(int i=head[u]; ~i; i=ne[i])
|
||||
{
|
||||
if(!vis[v=to[i]])
|
||||
{
|
||||
vis[v]=1;
|
||||
dis[v]=dis[u]+w[i];
|
||||
que[r++]=v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int treediameter(int s)
|
||||
{
|
||||
int u,maxl;
|
||||
bfs(s);
|
||||
maxl=0,u=s;
|
||||
for(int i=1; i<=n; i++)
|
||||
if(dis[i]>maxl)
|
||||
u=i,maxl=dis[i];
|
||||
bfs(u);
|
||||
maxl=0;
|
||||
for(int i=1; i<=n; i++)
|
||||
if(dis[i]>maxl)
|
||||
maxl=dis[i];
|
||||
return maxl;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int u,v,d=1,t,i,j,x;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
init();
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i=1;i<=n-1;i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
add(u,v,1);
|
||||
}
|
||||
int ans=treediameter(1);
|
||||
ans++;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d",&x);
|
||||
if(x<=ans) printf("%d\n",x-1);
|
||||
else printf("%d\n",(x-ans)*2+ans-1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
char str[100050];
|
||||
int num[100050];
|
||||
int main()
|
||||
{
|
||||
int t,i;
|
||||
while(~scanf("%d",&t))
|
||||
{
|
||||
while(t--)
|
||||
{
|
||||
scanf("%s",str);
|
||||
int n;
|
||||
n = strlen(str);
|
||||
for(i = 0;i < n;i++)
|
||||
num[i] = str[i]-'0';
|
||||
int rest;
|
||||
rest = 0;
|
||||
for(i = 0;i < n;i++)
|
||||
rest += num[i];
|
||||
rest = 10-rest%10;
|
||||
num[n-1] += rest;
|
||||
int bit;
|
||||
bit = 0;
|
||||
if(num[n-1] > 9)
|
||||
{
|
||||
for(i = n-2;i >= 0;i--)
|
||||
{
|
||||
bit++;
|
||||
num[i]++;
|
||||
num[i] %= 10;
|
||||
if(num[i])
|
||||
break;
|
||||
}
|
||||
if(i<0)
|
||||
{
|
||||
printf("1");
|
||||
for(i = n-1;i > 0;i--)
|
||||
printf("0");
|
||||
puts("9");
|
||||
}
|
||||
else
|
||||
{
|
||||
num[n-1] = (num[n-1]+1000000-bit)%10;
|
||||
for(i = 0;i < n;i++)
|
||||
printf("%d",num[i]);
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(i = 0;i < n;i++)
|
||||
printf("%d",num[i]);
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const double PI = acos(-1.0);
|
||||
struct complex
|
||||
{
|
||||
double r,i;
|
||||
complex(double _r = 0,double _i = 0)
|
||||
{
|
||||
r = _r; i = _i;
|
||||
}
|
||||
complex operator +(const complex &b)
|
||||
{
|
||||
return complex(r+b.r,i+b.i);
|
||||
}
|
||||
complex operator -(const complex &b)
|
||||
{
|
||||
return complex(r-b.r,i-b.i);
|
||||
}
|
||||
complex operator *(const complex &b)
|
||||
{
|
||||
return complex(r*b.r-i*b.i,r*b.i+i*b.r);
|
||||
}
|
||||
};
|
||||
void change(complex y[],int len)
|
||||
{
|
||||
int i,j,k;
|
||||
for(i = 1, j = len/2;i < len-1;i++)
|
||||
{
|
||||
if(i < j)swap(y[i],y[j]);
|
||||
k = len/2;
|
||||
while( j >= k)
|
||||
{
|
||||
j -= k;
|
||||
k /= 2;
|
||||
}
|
||||
if(j < k)j += k;
|
||||
}
|
||||
}
|
||||
void fft(complex y[],int len,int on)
|
||||
{
|
||||
change(y,len);
|
||||
for(int h = 2;h <= len;h <<= 1)
|
||||
{
|
||||
complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
|
||||
for(int j = 0;j < len;j += h)
|
||||
{
|
||||
complex w(1,0);
|
||||
for(int k = j;k < j+h/2;k++)
|
||||
{
|
||||
complex u = y[k];
|
||||
complex t = w*y[k+h/2];
|
||||
y[k] = u+t;
|
||||
y[k+h/2] = u-t;
|
||||
w = w*wn;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(on == -1)
|
||||
for(int i = 0;i < len;i++)
|
||||
y[i].r /= len;
|
||||
}
|
||||
const int MAXN = 400040;
|
||||
complex x1[MAXN];
|
||||
int a[MAXN/4];
|
||||
long long num[MAXN];
|
||||
long long sum[MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
memset(num,0,sizeof(num));
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
num[a[i]]++;
|
||||
}
|
||||
sort(a,a+n);
|
||||
int len1 = a[n-1]+1;
|
||||
int len = 1;
|
||||
while( len < 2*len1 )len <<= 1;
|
||||
for(int i = 0;i < len1;i++)
|
||||
x1[i] = complex(num[i],0);
|
||||
for(int i = len1;i < len;i++)
|
||||
x1[i] = complex(0,0);
|
||||
fft(x1,len,1);
|
||||
for(int i = 0;i < len;i++)
|
||||
x1[i] = x1[i]*x1[i];
|
||||
fft(x1,len,-1);
|
||||
for(int i = 0;i < len;i++)
|
||||
num[i] = (long long)(x1[i].r+0.5);
|
||||
len = 2*a[n-1];
|
||||
for(int i = 0;i < n;i++)
|
||||
num[a[i]+a[i]]--;
|
||||
for(int i = 1;i <= len;i++)
|
||||
{
|
||||
num[i]/=2;
|
||||
}
|
||||
sum[0] = 0;
|
||||
for(int i = 1;i <= len;i++)
|
||||
sum[i] = sum[i-1]+num[i];
|
||||
long long cnt = 0;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
cnt += sum[len]-sum[a[i]];
|
||||
cnt -= (long long)(n-1-i)*i;
|
||||
cnt -= (n-1);
|
||||
cnt -= (long long)(n-1-i)*(n-i-2)/2;
|
||||
}
|
||||
long long tot = (long long)n*(n-1)*(n-2)/6;
|
||||
printf("%.7lf\n",(double)cnt/tot);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<bitset>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int N = (int)4e6+10;
|
||||
const int M = (int)1e6+10;
|
||||
typedef pair<int,int> pii;
|
||||
bool p[N];
|
||||
int prime[M];
|
||||
void init(){
|
||||
memset(p,true,sizeof(p));
|
||||
p[0] = p[1] = false;
|
||||
for(int i=2;i*i<N;i++)
|
||||
for(int j=i;j*i<N;j++)
|
||||
p[i*j] = 0;
|
||||
prime[0] = 0;
|
||||
for(int i=2;i<N;i++)
|
||||
if(p[i])prime[++prime[0]] = i;
|
||||
}
|
||||
vector<pii>factor;
|
||||
void div(int n){
|
||||
factor.clear();
|
||||
for(int i=1;prime[i] * prime[i] <= n;i++){
|
||||
if(n % prime[i] == 0){
|
||||
int cnt = 0;
|
||||
while(n % prime[i] == 0){
|
||||
n /= prime[i];
|
||||
++cnt;
|
||||
}
|
||||
factor.push_back(make_pair(prime[i],cnt));
|
||||
}
|
||||
}
|
||||
if(n > 1)factor.push_back(make_pair(n,1));
|
||||
}
|
||||
ll Pow(ll a,ll b){
|
||||
ll ans = 1;
|
||||
while(b){
|
||||
if(b&1)ans = ans * a;
|
||||
a = a * a;
|
||||
b >>= 1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
bool isPrime_amount(int n){
|
||||
if(factor.size() > 1|| n==1 )return false;
|
||||
return p[factor[0].second + 1];
|
||||
}
|
||||
bool isPrime_sum(int n){
|
||||
if(factor.size() > 1|| n== 1)return false;
|
||||
int a = factor[0].first,b = factor[0].second;
|
||||
int sum = 1LL*(Pow(a,b+1) - 1) / (a - 1);
|
||||
return p[sum];
|
||||
}
|
||||
bool isSquare(ll n){
|
||||
ll _ = sqrt(n*1.0);
|
||||
return _ * _ == n;
|
||||
}
|
||||
bool isSquare_product(int n){
|
||||
int all = 1;
|
||||
for(int i=0;i<factor.size();i++)
|
||||
all *= factor[i].second + 1;
|
||||
ll sq = sqrt(n*1.0);
|
||||
ll cur = 1;
|
||||
int p = all >> 1;
|
||||
if(p & 1)cur *= n;
|
||||
if(all & 1)cur *= sq;
|
||||
return isSquare(cur);
|
||||
}
|
||||
int extra[5];
|
||||
int V[16],cur[5],hash[16];
|
||||
int have[16];
|
||||
int main(){
|
||||
for(int i=0;i<16;i++){
|
||||
int all = 0;
|
||||
for(int j=0;j<4;j++)
|
||||
if(!(i&(1<<j)))++all;
|
||||
have[i] = all;
|
||||
}
|
||||
init();
|
||||
int T,n,K;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
memset(V,0,sizeof(V));
|
||||
scanf("%d%d",&n,&K);
|
||||
for(int i=1;i<=n;i++){
|
||||
int a,b;
|
||||
scanf("%d%d",&a,&b);
|
||||
int flag = 15,cnt = 0;
|
||||
div(a);
|
||||
if(p[a])flag ^= 1<<0 ,cnt ++;
|
||||
if(isPrime_amount(a)) flag ^= 1<<1,cnt ++;
|
||||
if(isPrime_sum(a))flag ^= 1<<2,cnt ++;
|
||||
if(isSquare_product(a)) flag ^= 1<<3,cnt++;
|
||||
V[flag] += b;
|
||||
if(i!=1)printf(" ");
|
||||
printf("%d",cnt);
|
||||
}
|
||||
puts("");
|
||||
int ans = -(~0u>>2);
|
||||
for(int i=0;i< 4;i++)scanf("%d",&extra[i]);
|
||||
for(int i=0;i < 1<<16;i++){
|
||||
memset(cur,0,sizeof(cur));
|
||||
int res = K,number = 0,all = 0;
|
||||
int flag = 15;
|
||||
for(int j = 0;j < 16;j++){
|
||||
if(i&(1<<j)){
|
||||
if(V[j] > 0){
|
||||
flag &= j;
|
||||
res --;
|
||||
all += have[j];
|
||||
cur[have[j]] += V[j] - 1;
|
||||
}else{
|
||||
res = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(res < 0 )continue;
|
||||
for(int k=4;k >= 0 && res > 0;k--){
|
||||
if(cur[k] <= res){
|
||||
all += k * cur[k];
|
||||
res -= cur[k];
|
||||
}else{
|
||||
all += res * k;
|
||||
res =0;
|
||||
}
|
||||
}
|
||||
if(res == 0){
|
||||
for(int j=0;j<4;j++)
|
||||
if(flag & (1<<j))all += extra[j];
|
||||
ans = max(ans,all);
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
long long gcd(long long x,long long y)
|
||||
{
|
||||
return y==0?x:gcd(y,x%y);
|
||||
}
|
||||
long long Count(long long n,long long a,long long b)
|
||||
{
|
||||
long long now=0,ret=0,tmp,x=0,y=0;
|
||||
while(now<n)
|
||||
{
|
||||
tmp=min(a-x,b-y);
|
||||
if (now+tmp>n) tmp=n-now;
|
||||
ret+=tmp*abs(x-y);
|
||||
x=(x+tmp)%a;
|
||||
y=(y+tmp)%b;
|
||||
now+=tmp;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,T;
|
||||
long long a,b,n,l,ans;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
cin>>n>>a>>b;
|
||||
l=a*b/gcd(a,b);
|
||||
if (l>=n) ans=Count(n,a,b);
|
||||
else ans=Count(l,a,b)*(n/l)+Count(n%l,a,b);
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,171 @@
|
|||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cstdlib>
|
||||
#include<cstdio>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<vector>
|
||||
#include<cstring>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define CL(x,v); memset(x,v,sizeof(x));
|
||||
#define INF 0x3f3f3f3f
|
||||
#define LL long long
|
||||
#define REP(i,r,n) for(int i=r;i<=n;i++)
|
||||
#define RREP(i,n,r) for(int i=n;i>=r;i--)
|
||||
const int MAXN=2e5+100;
|
||||
int n,m;
|
||||
struct Edge{
|
||||
int u,v;
|
||||
Edge(){}
|
||||
Edge(int a,int b){
|
||||
u=a;
|
||||
v=b;
|
||||
}
|
||||
};
|
||||
vector<Edge> edges;
|
||||
vector<int> G[MAXN];
|
||||
vector<int> P[MAXN];
|
||||
int dfs_clock,bcc_cnt;
|
||||
int pre[MAXN];
|
||||
int T[MAXN];
|
||||
int dfs1(int u,int fa)
|
||||
{
|
||||
int lowu=pre[u]=++dfs_clock;
|
||||
for(int i=0;i<G[u].size();i++)
|
||||
{
|
||||
int mm=G[u][i];
|
||||
int v=edges[mm].v;
|
||||
if(fa==(mm^1))continue;
|
||||
if(!pre[v])
|
||||
{
|
||||
int lowv=dfs1(v,mm);
|
||||
lowu=min(lowu,lowv);
|
||||
if(lowv>pre[u])
|
||||
{
|
||||
P[v].push_back(u);
|
||||
P[u].push_back(v);
|
||||
}
|
||||
}
|
||||
else if(pre[v]<pre[u])
|
||||
{
|
||||
lowu=min(pre[v],lowu);
|
||||
}
|
||||
}
|
||||
return lowu;
|
||||
}
|
||||
void dfs2(int u,int fa)
|
||||
{
|
||||
T[u]=bcc_cnt;
|
||||
for(int i=0;i<G[u].size();i++)
|
||||
{
|
||||
int v=edges[G[u][i]].v;
|
||||
bool f=true;
|
||||
for(int j=0;j<P[u].size();j++)
|
||||
{
|
||||
int vv=P[u][j];
|
||||
if(v==vv)
|
||||
{
|
||||
f=false;break;
|
||||
}
|
||||
}
|
||||
if(!f||T[v])continue;
|
||||
dfs2(v,u);
|
||||
}
|
||||
}
|
||||
void find_bcc(int n)
|
||||
{
|
||||
dfs_clock=0,bcc_cnt=0;
|
||||
memset(pre,0,sizeof(pre));
|
||||
memset(T,0,sizeof(T));
|
||||
for(int i=1;i<=n;i++)
|
||||
if(!pre[i])
|
||||
dfs1(i,-1);
|
||||
for(int i=1;i<=n;i++)
|
||||
if(!T[i])
|
||||
{
|
||||
bcc_cnt++;
|
||||
dfs2(i,-1);
|
||||
}
|
||||
}
|
||||
vector<int> GG[MAXN];
|
||||
int d[MAXN];
|
||||
void dfs(int u,int dep)
|
||||
{
|
||||
d[u]=dep;
|
||||
for(int i=0;i<GG[u].size();i++)
|
||||
{
|
||||
int v=GG[u][i];
|
||||
if(!d[v])
|
||||
{
|
||||
dfs(v,dep+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
if(n+m==0)break;
|
||||
REP(i,0,n){
|
||||
G[i].clear();
|
||||
P[i].clear();
|
||||
}
|
||||
edges.clear();
|
||||
int a,b;
|
||||
REP(i,1,m)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
Edge e;
|
||||
e=Edge(a,b);
|
||||
edges.push_back(e);
|
||||
e=Edge(b,a);
|
||||
edges.push_back(e);
|
||||
int mm=edges.size();
|
||||
G[a].push_back(mm-2);
|
||||
G[b].push_back(mm-1);
|
||||
}
|
||||
find_bcc(n);
|
||||
REP(i,0,n)
|
||||
{
|
||||
GG[i].clear();
|
||||
}
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
for(int j=0;j<P[i].size();j++)
|
||||
{
|
||||
int v=P[i][j];
|
||||
if(T[i]!=T[v])
|
||||
{
|
||||
GG[T[i]].push_back(T[v]);
|
||||
}
|
||||
}
|
||||
}
|
||||
CL(d,0);
|
||||
dfs(1,1);
|
||||
int maxn=0;
|
||||
int flag=0;
|
||||
for(int i=1;i<=bcc_cnt;i++)
|
||||
{
|
||||
if(d[i]>maxn)
|
||||
{
|
||||
maxn=d[i];
|
||||
flag=i;
|
||||
}
|
||||
}
|
||||
CL(d,0);
|
||||
dfs(flag,1);
|
||||
maxn=0;
|
||||
for(int i=1;i<=bcc_cnt;i++)
|
||||
{
|
||||
if(d[i]>maxn)
|
||||
maxn=d[i];
|
||||
}
|
||||
cout<<bcc_cnt-maxn<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,205 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const int MAXN = 50010;
|
||||
struct Node
|
||||
{
|
||||
int l,r;
|
||||
int sum;
|
||||
int lazy;
|
||||
int first;
|
||||
int last;
|
||||
}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;
|
||||
if(segTree[i<<1].first != -1)segTree[i].first = segTree[i<<1].first;
|
||||
else segTree[i].first = segTree[(i<<1)|1].first;
|
||||
if(segTree[(i<<1)|1].last != -1)segTree[i].last = segTree[(i<<1)|1].last;
|
||||
else segTree[i].last = segTree[(i<<1)].last;
|
||||
}
|
||||
void push_down(int i)
|
||||
{
|
||||
if(segTree[i].r == segTree[i].l)return;
|
||||
if(segTree[i].lazy==1)
|
||||
{
|
||||
segTree[i<<1].first = segTree[i<<1].l;
|
||||
segTree[i<<1].last = segTree[i<<1].r;
|
||||
segTree[i<<1].sum = segTree[i<<1].r-segTree[i<<1].l+1;
|
||||
segTree[i<<1].lazy=1;
|
||||
segTree[(i<<1)|1].first = segTree[(i<<1)|1].l;
|
||||
segTree[(i<<1)|1].last = segTree[(i<<1)|1].r;
|
||||
segTree[(i<<1)|1].sum = segTree[(i<<1)|1].r-segTree[(i<<1)|1].l+1;
|
||||
segTree[(i<<1)|1].lazy=1;
|
||||
}
|
||||
if(segTree[i].lazy == -1)
|
||||
{
|
||||
segTree[i<<1].first = -1;
|
||||
segTree[i<<1].last = -1;
|
||||
segTree[i<<1].sum = 0;
|
||||
segTree[i<<1].lazy=-1;
|
||||
segTree[(i<<1)|1].first = -1;
|
||||
segTree[(i<<1)|1].last = -1;
|
||||
segTree[(i<<1)|1].sum = 0;
|
||||
segTree[(i<<1)|1].lazy=-1;
|
||||
}
|
||||
segTree[i].lazy = 0;
|
||||
}
|
||||
void build(int i,int l,int r)
|
||||
{
|
||||
segTree[i].l = l;
|
||||
segTree[i].r = r;
|
||||
segTree[i].sum = r-l+1;
|
||||
segTree[i].lazy = 0;
|
||||
segTree[i].first = l;
|
||||
segTree[i].last = r;
|
||||
if(l==r)return ;
|
||||
int mid = (l+r)/2;
|
||||
build(i<<1,l,mid);
|
||||
build((i<<1)|1,mid+1,r);
|
||||
}
|
||||
void update(int i,int l,int r,int type)
|
||||
{
|
||||
if(segTree[i].l == l && segTree[i].r==r)
|
||||
{
|
||||
if(type == 0)
|
||||
{
|
||||
if(segTree[i].sum == 0)return;
|
||||
segTree[i].sum = 0;
|
||||
segTree[i].lazy = -1;
|
||||
segTree[i].first = -1;
|
||||
segTree[i].last = -1;
|
||||
return;
|
||||
}
|
||||
else if(type == 1)
|
||||
{
|
||||
if(segTree[i].sum == segTree[i].r-segTree[i].l+1)return;
|
||||
segTree[i].sum = segTree[i].r-segTree[i].l+1;
|
||||
segTree[i].lazy = 1;
|
||||
segTree[i].first = segTree[i].l;
|
||||
segTree[i].last = segTree[i].r;
|
||||
return;
|
||||
}
|
||||
}
|
||||
push_down(i);
|
||||
int mid = (segTree[i].l + segTree[i].r)/2;
|
||||
if(r <= mid)update(i<<1,l,r,type);
|
||||
else if(l > mid)update((i<<1)|1,l,r,type);
|
||||
else
|
||||
{
|
||||
update(i<<1,l,mid,type);
|
||||
update((i<<1)|1,mid+1,r,type);
|
||||
}
|
||||
push_up(i);
|
||||
}
|
||||
int sum(int i,int l,int r)
|
||||
{
|
||||
if(segTree[i].l == l && segTree[i].r == r)
|
||||
{
|
||||
return segTree[i].sum;
|
||||
}
|
||||
push_down(i);
|
||||
int mid = (segTree[i].l + segTree[i].r)/2;
|
||||
if(r <= mid)return sum(i<<1,l,r);
|
||||
else if(l > mid)return sum((i<<1)|1,l,r);
|
||||
else return sum((i<<1)|1,mid+1,r)+sum(i<<1,l,mid);
|
||||
}
|
||||
int n,m;
|
||||
int query1(int i,int l,int r)
|
||||
{
|
||||
if(segTree[i].l == l && segTree[i].r == r)
|
||||
{
|
||||
return segTree[i].first;
|
||||
}
|
||||
push_down(i);
|
||||
int mid = (segTree[i].l + segTree[i].r)/2;
|
||||
int ans1,ans2;
|
||||
if(r <= mid)return query1(i<<1,l,r);
|
||||
else if(l > mid)return query1((i<<1)|1,l,r);
|
||||
else
|
||||
{
|
||||
ans1 = query1(i<<1,l,mid);
|
||||
if(ans1 != -1)return ans1;
|
||||
return query1((i<<1)|1,mid+1,r);
|
||||
}
|
||||
}
|
||||
int query2(int i,int l,int r)
|
||||
{
|
||||
if(segTree[i].l == l && segTree[i].r == r)
|
||||
{
|
||||
return segTree[i].last;
|
||||
}
|
||||
push_down(i);
|
||||
int mid = (segTree[i].l + segTree[i].r)/2;
|
||||
int ans1,ans2;
|
||||
if(r <= mid)return query2(i<<1,l,r);
|
||||
else if(l > mid)return query2((i<<1)|1,l,r);
|
||||
else
|
||||
{
|
||||
ans1 = query2((i<<1)|1,mid+1,r);
|
||||
if(ans1 != -1)return ans1;
|
||||
return query2(i<<1,l,mid);
|
||||
}
|
||||
}
|
||||
int bisearch(int A,int F)
|
||||
{
|
||||
if(sum(1,A,n)==0)return -1;
|
||||
if(sum(1,A,n)<F)return n;
|
||||
int l= A,r = n;
|
||||
int ans=A;
|
||||
while(l<=r)
|
||||
{
|
||||
int mid = (l+r)/2;
|
||||
if(sum(1,A,mid)>=F)
|
||||
{
|
||||
ans = mid;
|
||||
r = mid-1;
|
||||
}
|
||||
else l = mid+1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
build(1,1,n);
|
||||
int op,u,v;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d%d",&op,&u,&v);
|
||||
if(op == 1)
|
||||
{
|
||||
u++;
|
||||
int t = bisearch(u,v);
|
||||
if(t==-1)
|
||||
{
|
||||
printf("Can not put any one.\n");
|
||||
continue;
|
||||
}
|
||||
printf("%d %d\n",query1(1,u,t)-1,query2(1,u,t)-1);
|
||||
update(1,u,t,0);
|
||||
}
|
||||
else
|
||||
{
|
||||
u++;v++;
|
||||
printf("%d\n",v-u+1-sum(1,u,v));
|
||||
update(1,u,v,1);
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#define N 50005
|
||||
#define INF 99999999
|
||||
struct Edge
|
||||
{
|
||||
int e, next;
|
||||
}edge[N*2];
|
||||
int head[N], eNum;
|
||||
int c[N], val[N], n, k, ans, dp[N][4][2];
|
||||
void init()
|
||||
{
|
||||
memset(head, -1, sizeof(head));
|
||||
eNum = 0; ans = 0;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
for(int j=0; j<4; j++)
|
||||
{
|
||||
for(int l=0; l<2; l++)
|
||||
dp[i][j][l] = -INF;
|
||||
}
|
||||
}
|
||||
}
|
||||
void AddEdge(int u, int v)
|
||||
{
|
||||
edge[eNum].e = v;
|
||||
edge[eNum].next = head[u];
|
||||
head[u] = eNum++;
|
||||
}
|
||||
int max2(int x, int y)
|
||||
{
|
||||
return x > y ? x : y;
|
||||
}
|
||||
void dfs(int u, int fa)
|
||||
{
|
||||
dp[u][c[u]][c[u]] = val[u];
|
||||
for(int i=head[u]; i!=-1; i=edge[i].next)
|
||||
{
|
||||
int v = edge[i].e;
|
||||
if(v==fa) continue;
|
||||
dfs(v, u);
|
||||
for(int j=0; j<=k; j++)
|
||||
{
|
||||
for(int l=0; l+j<=k; l++)
|
||||
{
|
||||
ans = max2(ans, dp[u][j][1]+dp[v][l][1]);
|
||||
if(j+l!=k) ans = max2(ans, dp[u][j][0]+dp[v][l][0]);
|
||||
ans = max2(ans, dp[u][j][0]+dp[v][l][1]);
|
||||
ans = max2(ans, dp[u][j][1]+dp[v][l][0]);
|
||||
}
|
||||
}
|
||||
for(int j=0; j<k; j++)
|
||||
{
|
||||
dp[u][j+c[u]][1] = max2(dp[u][j+c[u]][1],dp[v][j][1]+val[u]);
|
||||
dp[u][j+c[u]][0] = max2(dp[u][j+c[u]][0],dp[v][j][0]+val[u]);
|
||||
}
|
||||
if(c[u]==0) dp[u][k][1] = max2(dp[u][k][1], dp[v][k][1]+val[u]);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&k);
|
||||
for(int i=0; i<n; i++)
|
||||
scanf("%d%d",&val[i],&c[i]);
|
||||
init();
|
||||
int u, v;
|
||||
for(int i=0; i<n-1; i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
AddEdge(u, v);
|
||||
AddEdge(v, u);
|
||||
}
|
||||
dfs(0,-1);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const double eps = 1e-8;
|
||||
int sgn(double x)
|
||||
{
|
||||
if(fabs(x) < eps)return 0;
|
||||
if(x < 0)return -1;
|
||||
else return 1;
|
||||
}
|
||||
struct Point3D
|
||||
{
|
||||
double x,y,z;
|
||||
Point3D(double _x = 0,double _y = 0,double _z = 0)
|
||||
{
|
||||
x = _x;
|
||||
y = _y;
|
||||
z = _z;
|
||||
}
|
||||
Point3D operator -(const Point3D &b)const
|
||||
{
|
||||
return Point3D(x-b.x,y-b.y,z-b.z);
|
||||
}
|
||||
Point3D operator ^(const Point3D &b)const
|
||||
{
|
||||
return Point3D(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);
|
||||
}
|
||||
double operator *(const Point3D &b)const
|
||||
{
|
||||
return x*b.x+y*b.y+z*b.z;
|
||||
}
|
||||
void input()
|
||||
{
|
||||
scanf("%lf%lf%lf",&x,&y,&z);
|
||||
}
|
||||
};
|
||||
double Norm(Point3D p)
|
||||
{
|
||||
return sqrt(p*p);
|
||||
}
|
||||
double calc(Point3D a,Point3D k1,Point3D b,Point3D k2)
|
||||
{
|
||||
Point3D tmp = k1^k2;
|
||||
return fabs(tmp*(a-b))/sqrt(tmp*tmp);
|
||||
}
|
||||
struct Node
|
||||
{
|
||||
Point3D o,p1,p2;
|
||||
void input()
|
||||
{
|
||||
o.input();
|
||||
p1.input();
|
||||
p2.input();
|
||||
}
|
||||
}node[50];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i = 0;i < n;i++)
|
||||
node[i].input();
|
||||
bool flag = false;
|
||||
double Min = 1e20;
|
||||
for(int i = 0;i < n;i++)
|
||||
for(int j = i+1;j < n;j++)
|
||||
{
|
||||
if(flag)break;
|
||||
double r1 = sqrt((node[i].p1-node[i].o)*(node[i].p1-node[i].o));
|
||||
double r2 = sqrt((node[j].p1-node[j].o)*(node[j].p1-node[j].o));
|
||||
Point3D k1 = (node[i].p1-node[i].o)^(node[i].p2-node[i].o);
|
||||
Point3D k2 = (node[j].p1-node[j].o)^(node[j].p2-node[j].o);
|
||||
if(sgn(Norm(k1^k2))==0)
|
||||
{
|
||||
if(sgn( Norm( k1^(node[i].o-node[j].o)) ) == 0)
|
||||
{
|
||||
if(sgn(r1-r2) == 0)
|
||||
{
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
else continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
double dd = (k1*(node[i].o-node[j].o))/Norm(k1);
|
||||
double d = sqrt( Norm(node[i].o-node[j].o)*Norm(node[i].o-node[j].o) - dd*dd );
|
||||
if(d > fabs(r1-r2) &&d < fabs(r1+r2))
|
||||
{
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
Min = min(Min,d-r1-r2);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
double d = calc(node[i].o,k1,node[j].o,k2);
|
||||
if(d < r1 + r2 -eps)
|
||||
{
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
Min = min(Min,d-r1-r2);
|
||||
}
|
||||
if(flag || sgn(Min)<=0)printf("Lucky\n");
|
||||
else printf("%.2lf\n",Min);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<string.h>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
const int MAXN=2505;
|
||||
int linker[MAXN];
|
||||
bool used[MAXN];
|
||||
vector<int>map[MAXN];
|
||||
int uN;
|
||||
bool dfs(int u)
|
||||
{
|
||||
for(int i=0;i<map[u].size();i++)
|
||||
{
|
||||
if(!used[map[u][i]])
|
||||
{
|
||||
used[map[u][i]]=true;
|
||||
if(linker[map[u][i]]==-1||dfs(linker[map[u][i]]))
|
||||
{
|
||||
linker[map[u][i]]=u;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int hungary()
|
||||
{
|
||||
int u;
|
||||
int res=0;
|
||||
memset(linker,-1,sizeof(linker));
|
||||
for(u=0;u<uN;u++)
|
||||
{
|
||||
memset(used,false,sizeof(used));
|
||||
if(dfs(u)) res++;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
pair<int,int>p1[MAXN];
|
||||
pair<int,int>p2[MAXN];
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int x,y;
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
if(n==0 &&m==0)break;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
p1[i]= make_pair(x,y);
|
||||
}
|
||||
for(int i = 0;i < m;i++)
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
p2[i]= make_pair(x,y);
|
||||
}
|
||||
uN = n;
|
||||
for(int i = 0;i < n;i++)
|
||||
map[i].clear();
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
for(int j = 0;j < m;j++)
|
||||
{
|
||||
int x1 = p1[i].first;
|
||||
int y1 = p1[i].second;
|
||||
int x2 = p2[j].first;
|
||||
int y2 = p2[j].second;
|
||||
if( (x1==x2 && y1==y2)
|
||||
||(x1==x2 && y1==y2+1)
|
||||
||(x1+1==x2 && y1==y2)
|
||||
||(x1+1==x2 && y1==y2+1)
|
||||
)
|
||||
map[i].push_back(j);
|
||||
}
|
||||
}
|
||||
int ans = n+m-hungary();
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int t,p[15],c,id;
|
||||
}cut[35];
|
||||
bool cmp(node x,node y)
|
||||
{
|
||||
return x.t<y.t;
|
||||
}
|
||||
int T,longe,ans[35],tmpa[35],tmpl,n,w,m,vis[205],num;
|
||||
void dfs(int pos,int lastt)
|
||||
{
|
||||
if(n-pos+tmpl<=longe) return;
|
||||
int num,i,j,tmp;
|
||||
for(i=pos+1;i<=n;i++)
|
||||
{
|
||||
for(j=1,num=0;j<=cut[i].c;j++)
|
||||
{
|
||||
tmp=cut[i].p[j];
|
||||
if(vis[tmp]==0)
|
||||
num++;
|
||||
vis[tmp]++;
|
||||
}
|
||||
if((cut[i].t-lastt<=w||!tmpl)&&num>=3)
|
||||
{
|
||||
tmpl++;
|
||||
tmpa[tmpl]=cut[i].id;
|
||||
dfs(i,cut[i].t);
|
||||
tmpl--;
|
||||
}
|
||||
for(j=1;j<=cut[i].c;j++)
|
||||
{
|
||||
tmp=cut[i].p[j];
|
||||
vis[tmp]--;
|
||||
}
|
||||
}
|
||||
if(longe<tmpl)
|
||||
{
|
||||
longe=tmpl;
|
||||
for(j=0;j<longe;j++)
|
||||
ans[j]=tmpa[j+1];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&w);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d%d",&cut[i].c,&cut[i].t);
|
||||
for(j=1;j<=cut[i].c;j++)
|
||||
scanf("%d",&cut[i].p[j]);
|
||||
cut[i].id=i;
|
||||
}
|
||||
sort(cut+1,cut+n+1,cmp);
|
||||
memset(vis,0,sizeof vis);
|
||||
longe=0;tmpl=0;
|
||||
dfs(0,cut[1].t);
|
||||
sort(ans,ans+longe);
|
||||
printf("%d\n",longe);
|
||||
for(i=0;i<longe-1;i++)
|
||||
printf("%d ",ans[i]);
|
||||
printf("%d\n",ans[longe-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include <stdlib.h>
|
||||
#define ll __int64
|
||||
using namespace std ;
|
||||
const int maxn = 1111111 ;
|
||||
ll f[maxn] , g[maxn] ;
|
||||
int wa[maxn] , wb[maxn] , wv[maxn] , ws[maxn] , pos[maxn] ;
|
||||
struct suf
|
||||
{
|
||||
int sa[maxn] , hei[maxn] , rank[maxn] ;
|
||||
int cmp ( int *r , int i , int j , int l )
|
||||
{
|
||||
return r[i] == r[j] && r[i+l] == r[j+l] ;
|
||||
}
|
||||
void da ( int *r , int n , int m )
|
||||
{
|
||||
int *x = wa , *y = wb , *t ;
|
||||
int i , j , p ;
|
||||
for ( i = 0 ; i < m ; i ++ ) ws[i] = 0 ;
|
||||
for ( i = 0 ; i < n ; i ++ ) ws[x[i]=r[i]] ++ ;
|
||||
for ( i = 1 ; i < m ; i ++ ) ws[i] += ws[i-1] ;
|
||||
for ( i = n - 1 ; i >= 0 ; i -- ) sa[--ws[x[i]]] = i ;
|
||||
for ( j = 1 , p = 1 ; p < n ; j *= 2 , m = p )
|
||||
{
|
||||
for ( p = 0 , i = n - j ; i < n ; i ++ ) y[p++] = i ;
|
||||
for ( i = 0 ; i < n ; i ++ ) if ( sa[i] >= j ) y[p++] = sa[i] - j ;
|
||||
for ( i = 0 ; i < m ; i ++ ) ws[i] = 0 ;
|
||||
for ( i = 0 ; i < n ; i ++ ) ws[x[i]] ++ ;
|
||||
for ( i = 1 ; i < m ; i ++ ) ws[i] += ws[i-1] ;
|
||||
for ( i = n - 1 ; i >= 0 ; i -- ) sa[--ws[x[y[i]]]] = y[i] ;
|
||||
for ( t = x , x = y , y = t , p = 1 , x[sa[0]] = 0 , i = 1 ; i < n ; i ++ )
|
||||
x[sa[i]] = cmp ( y , sa[i-1] , sa[i] , j ) ? p - 1 : p ++ ;
|
||||
}
|
||||
int k = 0 ;
|
||||
for ( i = 1 ; i < n ; i ++ ) rank[sa[i]] = i ;
|
||||
for ( i = 0 ; i < n - 1 ; hei[rank[i++]] = k )
|
||||
for ( k ? k -- : 0 , j = sa[rank[i]-1] ; r[i+k] == r[j+k] ; k ++ ) ;
|
||||
}
|
||||
int solve ( int n )
|
||||
{
|
||||
int ans = 0 , i ;
|
||||
for ( i = 1 ; i <= n ; i ++ )
|
||||
ans += n - sa[i] - hei[i] ;
|
||||
return ans ;
|
||||
}
|
||||
} arr ;
|
||||
int s1[maxn] , dp[20][2222] ;
|
||||
void rmq ( int n )
|
||||
{
|
||||
int i , j ;
|
||||
f[0] = 1 ;
|
||||
for ( i = 1 ; i <= 15 ; i ++ )
|
||||
f[i] = f[i-1] * 2 ;
|
||||
g[0] = -1 ;
|
||||
for ( i = 1 ; i < 2222 ; i ++ )
|
||||
g[i] = g[i>>1] + 1 ;
|
||||
for ( i = 1 ; f[i] <= n ; i ++ )
|
||||
for ( j = 1 ; j + f[i] - 1 <= n ; j ++ )
|
||||
dp[i][j] = min ( dp[i-1][j] , dp[i-1][j+f[i-1]] ) ;
|
||||
}
|
||||
int query ( int l , int r )
|
||||
{
|
||||
if ( l == r ) return dp[0][l] ;
|
||||
if ( l > r ) swap ( l , r ) ;
|
||||
int i , j , k ;
|
||||
k = g[r-l+1] ;
|
||||
return min ( dp[k][l] , dp[k][r-f[k]+1] ) ;
|
||||
}
|
||||
char s[maxn] ;
|
||||
int num[maxn] ;
|
||||
int main ()
|
||||
{
|
||||
int n , k , i , l , r ;
|
||||
int cas ;
|
||||
scanf ( "%d" , &cas ) ;
|
||||
while ( cas -- )
|
||||
{
|
||||
int q ;
|
||||
scanf ( "%s" , s ) ;
|
||||
int len = strlen ( s ) ;
|
||||
for ( i = 0 ; i < len ; i ++ ) s1[i] = s[i] ;
|
||||
s1[len] = 0 ;
|
||||
arr.da ( s1 , len + 1 , 555 ) ;
|
||||
for ( i = 1 ; i <= len ; i ++ )
|
||||
dp[0][i] = arr.hei[i] ;
|
||||
rmq ( len ) ;
|
||||
n = len ;
|
||||
scanf ( "%d" , &q ) ;
|
||||
while ( q -- )
|
||||
{
|
||||
scanf ( "%d%d" , &l , &r ) ;
|
||||
int ans = ( r - l + 1 ) * ( r - l + 2) / 2 ;
|
||||
for ( i = 0 ; i <= n ; i ++ ) pos[i] = -1 ;
|
||||
for ( i = l ; i <= r ; i ++ )
|
||||
pos[arr.rank[i-1]] = i - 1 ;
|
||||
int last = -1 , d = 0 ;
|
||||
for ( i = 1 ; i <= n ; i ++ )
|
||||
{
|
||||
if ( pos[i] != -1 )
|
||||
{
|
||||
if ( last != -1 )
|
||||
{
|
||||
int t = query ( arr.rank[last] + 1 , arr.rank[pos[i]] ) ;
|
||||
d = min ( d , t ) ;
|
||||
d = max ( d , min ( t , r - last ) ) ;
|
||||
ans -= min ( d , r - pos[i] );
|
||||
}
|
||||
last = pos[i] ;
|
||||
}
|
||||
}
|
||||
printf ( "%d\n" , ans ) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int prime[]={2,3,5,7,11,13,17,19,23};
|
||||
const int np=9;
|
||||
int state[30];
|
||||
int g[300][300];
|
||||
int vi[300];
|
||||
int num[30];
|
||||
int base[30];
|
||||
short dp[19][2000000];
|
||||
bool ok[29];
|
||||
int n,m,ns,st;
|
||||
void ini()
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
memset(g,0,sizeof(g));
|
||||
memset(vi,0,sizeof(vi));
|
||||
memset(num,0,sizeof(num));
|
||||
ns=0;
|
||||
state[++ns]=0;
|
||||
num[ns]=1;
|
||||
for(int i=2;i<=n;i++)
|
||||
{
|
||||
st=0;
|
||||
if(ok[i])
|
||||
{
|
||||
num[1]++;
|
||||
continue;
|
||||
}
|
||||
for(int j=0;j<np;j++)
|
||||
{
|
||||
if(i%prime[j]==0)
|
||||
{
|
||||
st|=(1<<j);
|
||||
}
|
||||
}
|
||||
if(!vi[st])
|
||||
{
|
||||
state[++ns]=st;
|
||||
num[ns]=1;
|
||||
vi[st]=ns;
|
||||
}
|
||||
else
|
||||
{
|
||||
num[vi[st]]++;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=ns;i++)
|
||||
{
|
||||
for(int j=1;j<=ns;j++)
|
||||
{
|
||||
if((state[i]&state[j])==0)
|
||||
g[i][j]=1;
|
||||
}
|
||||
}
|
||||
base[1]=1;
|
||||
st=0;
|
||||
for(int i=1;i<=ns;i++)
|
||||
{
|
||||
base[i+1]=base[i]*(num[i]+1);
|
||||
st+=base[i]*num[i];
|
||||
}
|
||||
}
|
||||
int getnum(int i,int x)
|
||||
{
|
||||
int res=(x%base[i+1])/(base[i]);
|
||||
return res;
|
||||
}
|
||||
int getstate(int i,int num)
|
||||
{
|
||||
return num*base[i];
|
||||
}
|
||||
void dfs(int t,int x)
|
||||
{
|
||||
if(t==0)
|
||||
{
|
||||
dp[x][0]=1;
|
||||
return ;
|
||||
}
|
||||
if(dp[x][t]!=-1)
|
||||
return;
|
||||
dp[x][t]=0;
|
||||
for(int i=1;i<=ns;i++)
|
||||
{
|
||||
if(g[x][i]&&getnum(i,t)>=1)
|
||||
{
|
||||
dfs(t-base[i],i);
|
||||
dp[x][t]=((int)dp[x][t]+dp[i][t-base[i]])%m;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
memset(ok,0,sizeof(ok));
|
||||
ok[17]=1;
|
||||
ok[19]=1;
|
||||
ok[23]=1;
|
||||
while(T--)
|
||||
{
|
||||
ini();
|
||||
memset(dp,-1,sizeof(dp));
|
||||
int ans=0;
|
||||
for(int i=1;i<=ns;i++)
|
||||
{
|
||||
dfs(st-base[i],i);
|
||||
ans=((int)ans+dp[i][st-base[i]])%m;
|
||||
}
|
||||
for(int i=1;i<=ns;i++)
|
||||
{
|
||||
while(num[i]>1)
|
||||
{
|
||||
ans=((int)ans*num[i])%m;
|
||||
num[i]--;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int maxn = 5e4 + 10;
|
||||
const int maxk = 5e2 + 10;
|
||||
const int mod = 10007;
|
||||
typedef long long LL;
|
||||
struct edge {
|
||||
int v, to;
|
||||
};
|
||||
vector<edge> E;
|
||||
int L[maxn];
|
||||
void graph_init()
|
||||
{
|
||||
E.clear();
|
||||
memset(L, -1, sizeof(L));
|
||||
}
|
||||
void graph_add(int u, int v)
|
||||
{
|
||||
edge t = {v, L[u]};
|
||||
L[u] = E.size();
|
||||
E.push_back(t);
|
||||
}
|
||||
int s[maxk][maxk];
|
||||
int f[maxk];
|
||||
int c[maxk][maxk];
|
||||
void init()
|
||||
{
|
||||
s[0][0] = f[0] = c[0][0] = 1;
|
||||
for (int i = 1; i < maxk; i++) {
|
||||
f[i] = f[i-1] * i % mod;
|
||||
c[i][0] = 1;
|
||||
for (int j = 1; j < maxk; j++) {
|
||||
s[i][j] = (j * s[i-1][j] % mod + s[i-1][j-1]) % mod;
|
||||
c[i][j] = (c[i-1][j] + c[i-1][j-1]) % mod;
|
||||
}
|
||||
}
|
||||
}
|
||||
int n, k;
|
||||
int d[maxn][maxk];
|
||||
void dp_son(int u = 0, int p = -1)
|
||||
{
|
||||
memset(d[u], 0, sizeof(d[u]));
|
||||
for (int i = L[u]; i != -1; i = E[i].to)
|
||||
if (i != p) {
|
||||
int v = E[i].v;
|
||||
dp_son(v, i^1);
|
||||
for (int j = 0; j <= k; j++)
|
||||
d[u][j] = (d[u][j] + d[v][j] + (j? d[v][j-1]: 0) + c[1][j]) % mod;
|
||||
}
|
||||
}
|
||||
int tmp[maxk];
|
||||
void dp_father(int u = 0, int p = -1)
|
||||
{
|
||||
if (p != -1) {
|
||||
int v = E[p].v;
|
||||
memcpy(tmp, d[v], sizeof(d[v]));
|
||||
for (int j = 0; j <= k; j++)
|
||||
tmp[j] = (tmp[j] - (d[u][j] + (j? d[u][j-1]: 0) + c[1][j]) % mod + mod) % mod;
|
||||
for (int j = 0; j <= k; j++)
|
||||
d[u][j] = (d[u][j] + tmp[j] + (j? tmp[j-1]: 0) + c[1][j]) % mod;
|
||||
}
|
||||
for (int i = L[u]; i != -1; i = E[i].to)
|
||||
if (i != p) dp_father(E[i].v, i^1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
for ( ; T--; ) {
|
||||
graph_init();
|
||||
scanf("%d%d", &n, &k);
|
||||
for (int i = 0; i < n-1; i++) {
|
||||
int u, v;
|
||||
scanf("%d%d", &u, &v);
|
||||
u--, v--;
|
||||
graph_add(u, v);
|
||||
graph_add(v, u);
|
||||
}
|
||||
dp_son();
|
||||
dp_father();
|
||||
for (int u = 0; u < n; u++) {
|
||||
int sum = 0;
|
||||
for (int i = 0; i <= k; i++)
|
||||
sum = (sum + s[k][i]*f[i]%mod*d[u][i]%mod) % mod;
|
||||
printf("%d\n", sum);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
__int64 n;
|
||||
scanf("%I64d",&n);
|
||||
if(n==2)
|
||||
{
|
||||
printf("1\n");
|
||||
continue;
|
||||
}
|
||||
if(n&1)
|
||||
printf("%I64d\n",(n/2)*(n/2+1));
|
||||
else
|
||||
{
|
||||
n/=2;
|
||||
if(n&1)
|
||||
printf("%I64d\n",(n-2)*(n+2));
|
||||
else
|
||||
printf("%I64d\n",(n-1)*(n+1));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
bool legal[(1<<16)+1];
|
||||
int dp[(1<<16)+1];
|
||||
char s[20];
|
||||
char str[20];
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%s",s);
|
||||
int num=0;
|
||||
int len=strlen(s);
|
||||
for(int i=1;i<(1<<len);i++)
|
||||
{
|
||||
int cnt=0;
|
||||
for(int j=0;j<len;j++)
|
||||
if(i&(1<<j))
|
||||
str[cnt++]=s[j];
|
||||
int l=0,r=cnt-1;
|
||||
while(l<r && str[l]==str[r])
|
||||
{
|
||||
l++;
|
||||
r--;
|
||||
}
|
||||
if(l==r || l-1==r)
|
||||
legal[i]=true;
|
||||
else
|
||||
legal[i]=false;
|
||||
}
|
||||
memset(dp,0x3f,sizeof(dp));
|
||||
dp[0]=0;
|
||||
for(int i=1;i<(1<<len);i++)
|
||||
{
|
||||
for(int j=i;j>0;j=i&(j-1))
|
||||
if(legal[j])
|
||||
dp[i]=min(dp[i],dp[i-j]+1);
|
||||
}
|
||||
printf("%d\n",dp[(1<<len)-1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<cstdlib>
|
||||
#define pbk push_back
|
||||
using namespace std;
|
||||
const int N = 25050+10;
|
||||
const double eps = 1e-10;
|
||||
inline double sqr(double x){
|
||||
return x * x;
|
||||
}
|
||||
inline int dcmp(double x){
|
||||
return x < -eps ? -1 : x > eps;
|
||||
}
|
||||
struct Point{
|
||||
double x,y;
|
||||
int kind;
|
||||
Point(){}
|
||||
Point(double x,double y,int kind = 0):x(x),y(y),kind(kind){}
|
||||
bool operator < (const Point &p)const{
|
||||
return dcmp(x - p.x) < 0 || ( dcmp(x - p.x) == 0 && dcmp(y - p.y) < 0 );
|
||||
}
|
||||
Point operator - (const Point &p)const{
|
||||
return Point(x - p.x, y - p.y);
|
||||
}
|
||||
Point operator + (const Point &p)const{
|
||||
return Point(x + p.x, y + p.y);
|
||||
}
|
||||
Point operator * (const double &k)const{
|
||||
return Point (x*k , y*k);
|
||||
}
|
||||
Point operator / (const double &k)const{
|
||||
return Point (x/k, y/k);
|
||||
}
|
||||
double operator * (const Point &p)const{
|
||||
return x * p.y - y * p.x;
|
||||
}
|
||||
double operator / (const Point &p)const{
|
||||
return x * p.x + y * p.y;
|
||||
}
|
||||
void input(){
|
||||
scanf("%lf%lf",&x,&y);
|
||||
}
|
||||
void ot(){
|
||||
printf("%lf %lf\n",x,y);
|
||||
}
|
||||
};
|
||||
struct Line{
|
||||
Point a,b;
|
||||
int kind;
|
||||
Line (){}
|
||||
Line (Point a,Point b,int kind = 0):a(a),b(b),kind(kind){}
|
||||
double operator * (const Point &p)const{
|
||||
return ( b - a ) * ( p - a );
|
||||
}
|
||||
double operator / (const Point &p)const{
|
||||
return ( p - a) / ( p - b);
|
||||
}
|
||||
bool parallel(const Line &v){
|
||||
return !dcmp( ( b - a ) * ( v.b - v.a ) );
|
||||
}
|
||||
int LineCrossLine(const Line &v){
|
||||
if ( (*this).parallel(v) ){
|
||||
return ( dcmp( v * a ) == 0);
|
||||
}return 2;
|
||||
}
|
||||
int SegCrossSeg(const Line &v){
|
||||
int d1 = dcmp( (*this) * v.a);
|
||||
int d2 = dcmp( (*this) * v.b);
|
||||
int d3 = dcmp( v * a);
|
||||
int d4 = dcmp( v * b);
|
||||
if ( ( d1 ^ d2 ) == -2 && ( d3 ^ d4 ) == -2 ) return 2;
|
||||
return ( ( d1 == 0 && dcmp( (*this) / v.a ) <= 0 )
|
||||
|| ( d2 == 0 && dcmp( (*this) / v.b ) <= 0 )
|
||||
|| ( d3 == 0 && dcmp( v / a ) <= 0 )
|
||||
|| ( d4 == 0 && dcmp( v / b ) <= 0 )
|
||||
);
|
||||
}
|
||||
Point CrossPoint(const Line &v){
|
||||
double s1 = v * a, s2 = v * b;
|
||||
return ( a * s2 - b * s1) / (s2 - s1);
|
||||
}
|
||||
void input(){
|
||||
a.input(); b.input();
|
||||
}
|
||||
void ot(){
|
||||
a.ot(); b.ot();
|
||||
}
|
||||
};
|
||||
int n,poly_n,xn;
|
||||
vector<double> lx;
|
||||
vector<Line> line;
|
||||
double ans[N];
|
||||
void init(){
|
||||
int sz = line.size();
|
||||
for (int i = 0; i < sz; i++){
|
||||
for (int j = i+1; j < sz; j++){
|
||||
if (line[i].SegCrossSeg(line[j]) == 2){
|
||||
Point p = line[i].CrossPoint(line[j]);
|
||||
lx.pbk(p.x);
|
||||
}
|
||||
}
|
||||
}
|
||||
sort(lx.begin(),lx.end());
|
||||
xn = unique(lx.begin(),lx.end()) - lx.begin();
|
||||
}
|
||||
vector<Point> qu[N];
|
||||
void work(){
|
||||
for (int i = 0; i <= n; i++) ans[i] = 0;
|
||||
for (int i = 0; i < xn-1; i++){
|
||||
int k = 0;
|
||||
for (int j = 0; j+1 < qu[i].size(); j++){
|
||||
k += qu[i][j].kind;
|
||||
ans[ k ] += (lx[i+1] - lx[i]) * (qu[i][j+1].x+qu[i][j+1].y - qu[i][j].x - qu[i][j].y) / 2;
|
||||
}
|
||||
}
|
||||
for (int i = 1; i <= n; i++) printf("%.10lf\n",ans[i]);
|
||||
}
|
||||
void solve(){
|
||||
for (int i = 0; i < xn; i++) qu[i].clear();
|
||||
for (int i = 0; i < line.size(); i++){
|
||||
int j = lower_bound(lx.begin(),lx.begin()+xn,line[i].a.x) - lx.begin();
|
||||
for (; j+1 < xn; j++ ){
|
||||
double l = lx[j], r = lx[j+1];
|
||||
if (dcmp(r - line[i].b.x) > 0) break;
|
||||
Point p1 = line[i].CrossPoint(Line(Point(l,0), Point(l,1)));
|
||||
Point p2 = line[i].CrossPoint(Line(Point(r,0), Point(r,1)));
|
||||
qu[j].pbk(Point(p1.y, p2.y,line[i].kind));
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < xn - 1; i++) sort(qu[i].begin(), qu[i].end());
|
||||
work();
|
||||
}
|
||||
int main(){
|
||||
int T; scanf("%d",&T);
|
||||
while (T--){
|
||||
scanf("%d",&n);
|
||||
lx.clear(); line.clear();;
|
||||
for (int i = 0; i < n ;i++){
|
||||
Point t[4];
|
||||
for (int j = 0; j < 3; j++ ){
|
||||
t[j].input();
|
||||
}
|
||||
t[3] = t[0];
|
||||
int flag = 1;
|
||||
if (dcmp( (t[1] - t[0])*(t[2] - t[0]) ) == 0) flag = 0;
|
||||
for (int i = 0; i < 3 && flag; i++ ){
|
||||
lx.pbk(t[i].x);
|
||||
for (int j = i+1; j < 3; j++){
|
||||
Line tmp; tmp.a = t[i]; tmp.b = t[j];
|
||||
if (dcmp( tmp.a.x - tmp.b.x ) > 0) swap(tmp.a, tmp.b);
|
||||
Line tmp2 = Line(t[3-i-j], Point(t[3-i-j].x, t[3-i-j].y - 1));
|
||||
if (tmp.LineCrossLine(tmp2) != 2) continue;
|
||||
Point tp = tmp.CrossPoint(tmp2);
|
||||
if (dcmp(tp.y - t[3-i-j].y) < 0) tmp.kind = 1;
|
||||
else tmp.kind = -1;
|
||||
line.pbk(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define lz 2*u,l,mid
|
||||
#define rz 2*u+1,mid+1,r
|
||||
const int maxn=50005;
|
||||
int maxx[4*maxn], flag[4*maxn];
|
||||
int a[maxn];
|
||||
int pre[maxn];
|
||||
int n, m, T;
|
||||
vector<int>vt;
|
||||
struct node
|
||||
{
|
||||
int l, r, id;
|
||||
int ans;
|
||||
friend bool operator<(const node A, const node B)
|
||||
{
|
||||
return A.r<B.r;
|
||||
}
|
||||
}f[maxn];
|
||||
bool cmp(node A, node B)
|
||||
{
|
||||
return A.id<B.id;
|
||||
}
|
||||
void push_down(int u, int l, int r)
|
||||
{
|
||||
if(flag[u])
|
||||
{
|
||||
flag[2*u]=max(flag[2*u],flag[u]);
|
||||
flag[2*u+1]=max(flag[2*u+1],flag[u]);
|
||||
maxx[2*u]=max(maxx[2*u],flag[u]);
|
||||
maxx[2*u+1]=max(maxx[2*u+1],flag[u]);
|
||||
flag[u]=0;
|
||||
}
|
||||
}
|
||||
void Update(int u, int l, int r, int tl, int tr, int val)
|
||||
{
|
||||
maxx[u]=max(maxx[u],val);
|
||||
if(tl<=l&&r<=tr)
|
||||
{
|
||||
flag[u]=max(flag[u],val);
|
||||
maxx[u]=max(maxx[u],val);
|
||||
return ;
|
||||
}
|
||||
push_down(u,l,r);
|
||||
int mid=(l+r)>>1;
|
||||
if(tr<=mid) Update(lz,tl,tr,val);
|
||||
else if(tl>mid) Update(rz,tl,tr,val);
|
||||
else
|
||||
{
|
||||
Update(lz,tl,mid,val);
|
||||
Update(rz,mid+1,tr,val);
|
||||
}
|
||||
}
|
||||
int Query(int u, int l, int r, int tl, int tr)
|
||||
{
|
||||
if(tl<=l&&r<=tr) return maxx[u];
|
||||
push_down(u,l,r);
|
||||
int mid=(l+r)>>1;
|
||||
if(tr<=mid) return Query(lz,tl,tr);
|
||||
else if(tl>mid) return Query(rz,tl,tr);
|
||||
else
|
||||
{
|
||||
int t1=Query(lz,tl,mid);
|
||||
int t2=Query(rz,mid+1,tr);
|
||||
return max(t1,t2);
|
||||
}
|
||||
}
|
||||
void Solve(int x, int r)
|
||||
{
|
||||
vt.clear();
|
||||
vt.push_back(x);
|
||||
for(int i=2; i*i<=x; i++)
|
||||
if(x%i==0)
|
||||
{
|
||||
vt.push_back(i);
|
||||
vt.push_back(x/i);
|
||||
}
|
||||
for(int i=0; i<vt.size(); i++)
|
||||
{
|
||||
int l=pre[ vt[i] ];
|
||||
pre[ vt[i] ]=r;
|
||||
if(l==-1||l==r) continue;
|
||||
Update(1,1,n,l,l,vt[i]);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cin >> T;
|
||||
while(T--)
|
||||
{
|
||||
cin >> n;
|
||||
for(int i=1; i<=n; i++) scanf("%d", a+i), pre[i]=-1;
|
||||
cin >> m;
|
||||
for(int i=1; i<=m; i++) f[i].id=i, scanf("%d%d",&f[i].l,&f[i].r);
|
||||
sort(f+1,f+m+1);
|
||||
for(int i=1; i<=4*n; i++) maxx[i]=1, flag[i]=0;
|
||||
int i=1, j=1;
|
||||
while(j<=m)
|
||||
{
|
||||
if(i<=f[j].r&&i<=n)
|
||||
{
|
||||
Solve(a[i],i);
|
||||
i++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(f[j].l!=f[j].r)f[j].ans=Query(1,1,n,f[j].l,f[j].r);
|
||||
else f[j].ans=0;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
sort(f+1,f+m+1,cmp);
|
||||
for(int i=1; i<=m; i++)
|
||||
printf("%d\n",f[i].ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
const int MAXN = 500010;
|
||||
struct Point
|
||||
{
|
||||
int x,y;
|
||||
int id;
|
||||
int index;
|
||||
Point(int _x = 0,int _y = 0,int _index = 0)
|
||||
{
|
||||
x = _x;
|
||||
y = _y;
|
||||
index = _index;
|
||||
}
|
||||
};
|
||||
Point P[MAXN];
|
||||
long long dist(Point a,Point b)
|
||||
{
|
||||
return ((long long)(a.x-b.x)*(a.x-b.x) + (long long)(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
Point p[MAXN];
|
||||
Point tmpt[MAXN];
|
||||
bool cmpxy(Point a,Point b)
|
||||
{
|
||||
if(a.x != b.x)return a.x < b.x;
|
||||
else return a.y < b.y;
|
||||
}
|
||||
bool cmpy(Point a,Point b)
|
||||
{
|
||||
return a.y < b.y;
|
||||
}
|
||||
pair<int,int> Closest_Pair(int left,int right)
|
||||
{
|
||||
long long d = (1LL<<50);
|
||||
if(left == right)return make_pair(left,right);
|
||||
if(left + 1 == right)
|
||||
return make_pair(left,right);
|
||||
int mid = (left+right)/2;
|
||||
pair<int,int>pr1 = Closest_Pair(left,mid);
|
||||
pair<int,int>pr2 = Closest_Pair(mid+1,right);
|
||||
long long d1,d2;
|
||||
if(pr1.first == pr1.second)
|
||||
d1 = (1LL<<50);
|
||||
else d1 = dist(p[pr1.first],p[pr1.second]);
|
||||
if(pr2.first == pr2.second)
|
||||
d2 = (1LL<<50);
|
||||
else d2 = dist(p[pr2.first],p[pr2.second]);
|
||||
pair<int,int>ans;
|
||||
if(d1 < d2)ans = pr1;
|
||||
else ans = pr2;
|
||||
d = min(d1,d2);
|
||||
int k = 0;
|
||||
for(int i = left;i <= right;i++)
|
||||
{
|
||||
if((long long)(p[mid].x - p[i].x)*(p[mid].x - p[i].x) <= d)
|
||||
tmpt[k++] = p[i];
|
||||
}
|
||||
sort(tmpt,tmpt+k,cmpy);
|
||||
for(int i = 0;i <k;i++)
|
||||
{
|
||||
for(int j = i+1;j < k && (long long)(tmpt[j].y - tmpt[i].y)*(tmpt[j].y - tmpt[i].y) < d;j++)
|
||||
{
|
||||
if(d > dist(tmpt[i],tmpt[j]))
|
||||
{
|
||||
d = dist(tmpt[i],tmpt[j]);
|
||||
ans = make_pair(tmpt[i].id,tmpt[j].id);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n,Ax,Ay,Bx,By,Cx,Cy;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d%d%d%d%d",&n,&Ax,&Bx,&Cx,&Ay,&By,&Cy);
|
||||
P[0] = Point(0,0,0);
|
||||
for(int i = 1;i <= n;i++)
|
||||
{
|
||||
long long x= ((long long)P[i-1].x*Ax + Bx)%Cx;
|
||||
long long y = ((long long)P[i-1].y*Ay + By)%Cy;
|
||||
P[i] = Point(x,y,i);
|
||||
}
|
||||
int end = n;
|
||||
long long ans = 0;
|
||||
while(end > 1)
|
||||
{
|
||||
for(int i = 0;i < end;i++)
|
||||
p[i] = P[i+1];
|
||||
sort(p,p+end,cmpxy);
|
||||
for(int i = 0;i < end;i++)
|
||||
p[i].id = i;
|
||||
pair<int,int>pr = Closest_Pair(0,end-1);
|
||||
int Max = max(p[pr.first].index,p[pr.second].index);
|
||||
ans += (long long)(end-Max+1)*dist(p[pr.first],p[pr.second]);
|
||||
end = Max-1;
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include"iostream"
|
||||
#include"cstdio"
|
||||
#include"cstring"
|
||||
using namespace std;
|
||||
const int N=1006;
|
||||
const int mod=10007;
|
||||
int n,lowbit[N];
|
||||
__int64 C[N],ans[N];
|
||||
char str[N];
|
||||
void update(int k,int dir)
|
||||
{
|
||||
while(0<k && k<=n)
|
||||
{
|
||||
C[k]=(C[k]+dir)%mod;
|
||||
k+=lowbit[k];
|
||||
}
|
||||
}
|
||||
int sum(int k)
|
||||
{
|
||||
__int64 p=0;
|
||||
while(0<k && k<=n)
|
||||
{
|
||||
p=(p+C[k])%mod;
|
||||
k-=lowbit[k];
|
||||
}
|
||||
return p;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,Case;
|
||||
int i,l;
|
||||
__int64 a,b,t;
|
||||
__int64 hehe;
|
||||
for(i=1;i<=1000;i++) lowbit[i]=i&(-i);
|
||||
cin>>T;
|
||||
for(Case=1;Case<=T;Case++)
|
||||
{
|
||||
hehe=0;
|
||||
scanf("%s",str+1);
|
||||
memset(C,0,sizeof(C));
|
||||
memset(ans,0,sizeof(ans));
|
||||
for(n=1;str[n];n++);
|
||||
n--;
|
||||
for(i=n;i>=1;i--)
|
||||
{
|
||||
ans[i]=1;
|
||||
update(i,1);
|
||||
for(l=n;l>i;l--)
|
||||
{
|
||||
if(str[l]==str[i])
|
||||
{
|
||||
a=sum(i);
|
||||
b=sum(l-1);
|
||||
t=(b-a)%mod;
|
||||
while(t<0) t+=mod;
|
||||
ans[i]=(ans[i]+1+t)%mod;
|
||||
update(l,1+t);
|
||||
}
|
||||
}
|
||||
}
|
||||
hehe=0;
|
||||
for(i=1;i<=n;i++) hehe=(hehe+ans[i])%mod;
|
||||
printf("Case %d: %I64d\n",Case,hehe);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const LL MOD=10007;
|
||||
LL quick_mod(LL a,LL b)
|
||||
{
|
||||
LL ans=1;
|
||||
a%=MOD;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
ans=ans*a%MOD;
|
||||
b--;
|
||||
}
|
||||
b>>=1;
|
||||
a=a*a%MOD;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
LL tt=1,t,k,ans;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
cin>>k;
|
||||
ans=quick_mod(k,74);
|
||||
ans+=3*(2*quick_mod(k,20)+quick_mod(k,38))%MOD;
|
||||
ans+=6*quick_mod(k,38);
|
||||
ans+=8*quick_mod(k,26);
|
||||
ans%=MOD;
|
||||
ans*=quick_mod(24,MOD-2);
|
||||
ans%=MOD;
|
||||
printf("Case %I64d: %I64d\n",tt++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
char g[220][220];
|
||||
int sx,sy,ex,ey;
|
||||
int n,m;
|
||||
int keynum;
|
||||
int key_s[220][220];
|
||||
int mo[][2] = {{0,1},{0,-1},{1,0},{-1,0}};
|
||||
struct Node
|
||||
{
|
||||
int key;
|
||||
int num;
|
||||
int x,y;
|
||||
};
|
||||
queue<Node>q;
|
||||
bool used[202][202][1<<7];
|
||||
bool used2[202][202][1<<7][4];
|
||||
int bfs()
|
||||
{
|
||||
while(!q.empty())q.pop();
|
||||
Node tmp,now;
|
||||
tmp.key = 0;
|
||||
tmp.num = 0;
|
||||
tmp.x = sx;
|
||||
tmp.y = sy;
|
||||
q.push(tmp);
|
||||
memset(used,false,sizeof(used));
|
||||
memset(used2,false,sizeof(used2));
|
||||
used[sx][sy][0] = true;
|
||||
while(!q.empty())
|
||||
{
|
||||
tmp = q.front();
|
||||
q.pop();
|
||||
for(int i = 0;i < 4;i++)
|
||||
{
|
||||
int mx = mo[i][0];
|
||||
int my = mo[i][1];
|
||||
int x = tmp.x;
|
||||
int y = tmp.y;
|
||||
int ss = tmp.key;
|
||||
while(1)
|
||||
{
|
||||
if(g[x][y] =='L')
|
||||
{
|
||||
mx = 0; my = -1;
|
||||
}
|
||||
if(g[x][y] == 'U')
|
||||
{
|
||||
mx = -1;my = 0;
|
||||
}
|
||||
if(g[x][y] == 'D')
|
||||
{
|
||||
mx = 1;my = 0;
|
||||
}
|
||||
if(g[x][y] == 'R')
|
||||
{
|
||||
mx = 0; my = 1;
|
||||
}
|
||||
int dir;
|
||||
if(mx==-1&&my==0)dir=0;
|
||||
else if(mx==1&&my==0)dir=1;
|
||||
else if(mx==0&&my==1)dir=2;
|
||||
else if(mx==0&&my==-1)dir=3;
|
||||
if(used2[x][y][ss][dir])break;
|
||||
used2[x][y][ss][dir] = true;
|
||||
x += mx;
|
||||
y += my;
|
||||
if(x < 0 || y < 0 || x >= n || y >= m)break;
|
||||
if(g[x][y] =='#')break;
|
||||
if( x == ex && y== ey && ss ==((1<<keynum)-1) )
|
||||
return tmp.num+1;
|
||||
if(g[x][y] =='L')
|
||||
{
|
||||
mx = 0; my = -1;
|
||||
}
|
||||
if(g[x][y] == 'U')
|
||||
{
|
||||
mx = -1;my = 0;
|
||||
}
|
||||
if(g[x][y] == 'D')
|
||||
{
|
||||
mx = 1;my = 0;
|
||||
}
|
||||
if(g[x][y] == 'R')
|
||||
{
|
||||
mx = 0; my = 1;
|
||||
}
|
||||
if(g[x][y] == 'K')
|
||||
ss |= key_s[x][y];
|
||||
if(x+mx >=0 && x+mx < n && y+my>=0 && y+my < m && g[x+mx][y+my]=='#')
|
||||
{
|
||||
if(used[x][y][ss])break;
|
||||
now.x = x;now.y = y;
|
||||
now.key = ss;
|
||||
now.num = tmp.num + 1;
|
||||
q.push(now);
|
||||
used[x][y][ss] = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
keynum = 0;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
scanf("%s",g[i]);
|
||||
for(int j = 0;j < m;j++)
|
||||
{
|
||||
if(g[i][j] == 'S')
|
||||
{
|
||||
sx = i;sy = j;
|
||||
}
|
||||
if(g[i][j] == 'E')
|
||||
{
|
||||
ex = i;ey = j;
|
||||
}
|
||||
if(g[i][j] == 'K')
|
||||
{
|
||||
key_s[i][j] = (1<<keynum);
|
||||
keynum++;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",bfs());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int VM=200010;
|
||||
const int EM=200010;
|
||||
const int INF=0x3f3f3f3f;
|
||||
struct Edge{
|
||||
int to,nxt;
|
||||
}edge[EM<<1];
|
||||
long long n,m,cnt,head[VM];
|
||||
long long dep,top,atype;
|
||||
long long dfn[VM],low[VM],vis[VM],stack[VM],belong[VM],indeg[VM],outdeg[VM],sum[VM];
|
||||
void addedge(int cu,int cv){
|
||||
edge[cnt].to=cv; edge[cnt].nxt=head[cu]; head[cu]=cnt++;
|
||||
}
|
||||
void Tarjan(int u){
|
||||
dfn[u]=low[u]=++dep;
|
||||
stack[top++]=u;
|
||||
vis[u]=1;
|
||||
for(int i=head[u];i!=-1;i=edge[i].nxt){
|
||||
int v=edge[i].to;
|
||||
if(!dfn[v]){
|
||||
Tarjan(v);
|
||||
low[u]=min(low[u],low[v]);
|
||||
}else if(vis[v]){
|
||||
low[u]=min(low[u],dfn[v]);
|
||||
}
|
||||
}
|
||||
int j;
|
||||
if(dfn[u]==low[u]){
|
||||
atype++;
|
||||
do{
|
||||
j=stack[--top];
|
||||
belong[j]=atype;
|
||||
sum[atype]++;
|
||||
vis[j]=0;
|
||||
}while(u!=j);
|
||||
}
|
||||
}
|
||||
void init(){
|
||||
cnt=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
dep=0, top=0, atype=0;
|
||||
memset(dfn,0,sizeof(dfn));
|
||||
memset(low,0,sizeof(low));
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(belong,0,sizeof(belong));
|
||||
memset(indeg,0,sizeof(indeg));
|
||||
memset(outdeg,0,sizeof(outdeg));
|
||||
memset(sum,0,sizeof(sum));
|
||||
}
|
||||
int main(){
|
||||
int t,cases=0;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
cin>>n>>m;
|
||||
if(n==1){
|
||||
printf("Case %d: -1\n",++cases);
|
||||
continue;
|
||||
}
|
||||
init();
|
||||
int u,v;
|
||||
for(int i=0;i<m;i++){
|
||||
scanf("%d%d",&u,&v);
|
||||
addedge(u,v);
|
||||
}
|
||||
for(int i=1;i<=n;i++)
|
||||
if(!dfn[i])
|
||||
Tarjan(i);
|
||||
if(atype==1){
|
||||
printf("Case %d: -1\n",++cases);
|
||||
continue;
|
||||
}
|
||||
for(int u=1;u<=n;u++)
|
||||
for(int i=head[u];i!=-1;i=edge[i].nxt){
|
||||
int v=edge[i].to;
|
||||
if(belong[u]!=belong[v]){
|
||||
outdeg[belong[u]]++;
|
||||
indeg[belong[v]]++;
|
||||
}
|
||||
}
|
||||
long long ans=0,tmp;
|
||||
for(long long i=1;i<=atype;i++)
|
||||
if(indeg[i]==0 || outdeg[i]==0){
|
||||
tmp=sum[i];
|
||||
ans=max(ans,tmp*(tmp-1)+(n-tmp)*(n-tmp-1)+tmp*(n-tmp)-m);
|
||||
}
|
||||
cout<<"Case "<<(++cases)<<": "<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#define MID(x,y) ((x+y)>>1)
|
||||
#define iabs(x) ((x)>0?(x):-(x))
|
||||
using namespace std;
|
||||
vector <int>v[40];
|
||||
inline void v_pb(int a,int b){
|
||||
v[a].push_back(b);
|
||||
}
|
||||
int num[40];
|
||||
queue<int>q;
|
||||
bool vis[40];
|
||||
bool bfs(int s,int flag){
|
||||
while(!q.empty()) q.pop();
|
||||
q.push(s);
|
||||
int cnt = -1;
|
||||
while(!q.empty()){
|
||||
int k = q.front(); q.pop();
|
||||
cnt++;
|
||||
for (int i = 0; i < v[k].size(); i++){
|
||||
int d = v[k][i];
|
||||
if (!vis[d] && num[d] == flag){
|
||||
vis[d] = 1;
|
||||
q.push(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(flag == 0 && cnt == 0)return 1;
|
||||
return 0;
|
||||
}
|
||||
int main(){
|
||||
v_pb(1,2);v_pb(1,3);v_pb(1,17);v_pb(1,18);v_pb(1,20);v_pb(1,13);
|
||||
v_pb(2,1);v_pb(2,3);v_pb(2,4);v_pb(2,7);v_pb(2,12);v_pb(2,13);
|
||||
v_pb(3,1);v_pb(3,2);v_pb(3,4);v_pb(3,5);v_pb(3,20);
|
||||
v_pb(4,2);v_pb(4,3);v_pb(4,5);v_pb(4,6);v_pb(4,7);v_pb(4,8);
|
||||
v_pb(5,3);v_pb(5,4);v_pb(5,6);v_pb(5,20);v_pb(5,21);v_pb(5,24);
|
||||
v_pb(6,4);v_pb(6,5);v_pb(6,8);v_pb(6,9);v_pb(6,24);
|
||||
v_pb(7,2);v_pb(7,4);v_pb(7,8);v_pb(7,10);v_pb(7,12);
|
||||
v_pb(8,4);v_pb(8,6);v_pb(8,7);v_pb(8,9);v_pb(8,10);v_pb(8,11);
|
||||
v_pb(9,6);v_pb(9,8);v_pb(9,11);v_pb(9,24);v_pb(9,26);v_pb(9,27);
|
||||
v_pb(10,7);v_pb(10,8);v_pb(10,11);v_pb(10,12);v_pb(10,14);v_pb(10,16);
|
||||
v_pb(11,8);v_pb(11,9);v_pb(11,10);v_pb(11,16);v_pb(11,27);
|
||||
v_pb(12,2);v_pb(12,7);v_pb(12,10);v_pb(12,13);v_pb(12,14);v_pb(12,15);
|
||||
v_pb(13,12);v_pb(13,15);v_pb(13,2);v_pb(13,1);v_pb(13,17);
|
||||
v_pb(14,10);v_pb(14,12);v_pb(14,15);v_pb(14,16);v_pb(14,30);
|
||||
v_pb(15,12);v_pb(15,13);v_pb(15,14);v_pb(15,30);v_pb(15,32);v_pb(15,17);
|
||||
v_pb(16,10);v_pb(16,11);v_pb(16,14);v_pb(16,27);v_pb(16,29);v_pb(16,30);
|
||||
v_pb(17,1);v_pb(17,18);v_pb(17,19);v_pb(17,13);v_pb(17,15);v_pb(17,32);
|
||||
v_pb(18,1);v_pb(18,17);v_pb(18,19);v_pb(18,20);v_pb(18,22);
|
||||
v_pb(19,17);v_pb(19,18);v_pb(19,31);v_pb(19,22);v_pb(19,23);v_pb(19,32);
|
||||
v_pb(20,1);v_pb(20,3);v_pb(20,5);v_pb(20,18);v_pb(20,21);v_pb(20,22);
|
||||
v_pb(21,5);v_pb(21,20);v_pb(21,22);v_pb(21,24);v_pb(21,25);
|
||||
v_pb(22,19);v_pb(22,18);v_pb(22,20);v_pb(22,21);v_pb(22,23);v_pb(22,25);
|
||||
v_pb(23,19);v_pb(23,22);v_pb(23,25);v_pb(23,28);v_pb(23,31);
|
||||
v_pb(24,5);v_pb(24,6);v_pb(24,9);v_pb(24,21);v_pb(24,25);v_pb(24,26);
|
||||
v_pb(25,21);v_pb(25,22);v_pb(25,23);v_pb(25,24);v_pb(25,26);v_pb(25,28);
|
||||
v_pb(26,9);v_pb(26,24);v_pb(26,25);v_pb(26,27);v_pb(26,28);
|
||||
v_pb(27,9);v_pb(27,11);v_pb(27,16);v_pb(27,26);v_pb(27,28);v_pb(27,29);
|
||||
v_pb(28,25);v_pb(28,26);v_pb(28,27);v_pb(28,29);v_pb(28,31);v_pb(28,23);
|
||||
v_pb(29,16);v_pb(29,27);v_pb(29,28);v_pb(29,30);v_pb(29,31);
|
||||
v_pb(30,14);v_pb(30,15);v_pb(30,16);v_pb(30,29);v_pb(30,31);v_pb(30,32);
|
||||
v_pb(31,28);v_pb(31,29);v_pb(31,30);v_pb(31,32);v_pb(31,23);v_pb(31,19);
|
||||
v_pb(32,30);v_pb(32,31);v_pb(32,15);v_pb(32,19);v_pb(32,17);
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
for (int cas = 1; cas <= t; cas++){
|
||||
printf("Case %d: ", cas);
|
||||
int black = 0,white = 0;
|
||||
for (int i = 1; i <= 32; ++i){
|
||||
scanf("%d", &num[i]);
|
||||
if(num[i]) black ++;
|
||||
}
|
||||
if (black == 0) {puts("0");continue;}
|
||||
memset(vis,0,sizeof(vis));
|
||||
black = 0;
|
||||
for (int i = 1; i <= 32; ++i){
|
||||
if (!vis[i]){
|
||||
vis[i] = 1;
|
||||
if (num[i]){
|
||||
black ++;
|
||||
bfs(i,1);
|
||||
}else {
|
||||
white ++;
|
||||
if(bfs(i,0)) white --;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(black <= 2) printf("%d\n", black);
|
||||
else if (white == 1) puts("2");
|
||||
else puts("3");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,317 @@
|
|||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <set>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps=1e-10;
|
||||
const int INF=1<<29;
|
||||
const double PI=acos(-1.0);
|
||||
int doublecmp(double x){
|
||||
if(fabs(x)<eps)return 0;else return x<0?-1:1;
|
||||
}
|
||||
struct Point{
|
||||
double x,y;
|
||||
Point(double x=0,double y=0):x(x),y(y){}
|
||||
};
|
||||
typedef Point Vector;
|
||||
Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
|
||||
Vector operator-(Point a,Point b){return Vector(a.x-b.x,a.y-b.y);}
|
||||
Vector operator*(Vector a,double p){return Vector(a.x*p,a.y*p);}
|
||||
Vector operator/(Vector a,double p){return Vector(a.x/p,a.y/p);}
|
||||
bool operator<(const Point&a,const Point&b){return a.x<b.x||(a.x==b.x&&a.y<b.y);}
|
||||
bool operator==(const Point&a,const Point&b){
|
||||
return doublecmp(a.x-b.x)==0&&doublecmp(a.y-b.y)==0;
|
||||
}
|
||||
bool operator!=(const Point&a,const Point&b){return a==b?false:true;}
|
||||
struct Segment{
|
||||
Point a,b;
|
||||
Segment(){}
|
||||
Segment(Point _a,Point _b){a=_a,b=_b;}
|
||||
bool friend operator<(const Segment& p,const Segment& q){return p.a<q.a||(p.a==q.a&&p.b<q.b);}
|
||||
bool friend operator==(const Segment& p,const Segment& q){return (p.a==q.a&&p.b==q.b)||(p.a==q.b&&p.b==q.a);}
|
||||
};
|
||||
struct Circle{
|
||||
Point c;
|
||||
double r;
|
||||
Circle(){}
|
||||
Circle(Point _c, double _r):c(_c),r(_r) {}
|
||||
Point point(double a)const{return Point(c.x+cos(a)*r,c.y+sin(a)*r);}
|
||||
bool friend operator<(const Circle& a,const Circle& b){return a.r<b.r;}
|
||||
};
|
||||
struct Line{
|
||||
Point p;
|
||||
Vector v;
|
||||
double ang;
|
||||
Line() {}
|
||||
Line(const Point &_p, const Vector &_v):p(_p),v(_v){ang = atan2(v.y, v.x);}
|
||||
bool operator<(const Line &L)const{return ang < L.ang;}
|
||||
};
|
||||
double Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
|
||||
double Length(Vector a){return sqrt(Dot(a,a));}
|
||||
double Angle(Vector a,Vector b){return acos(Dot(a,b)/Length(a)/Length(b));}
|
||||
double Cross(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
|
||||
double Area2(Point a,Point b,Point c){return Cross(b-a,c-a);}
|
||||
double DegreeToRadius(double deg){return deg/180*PI;}
|
||||
double GetRerotateAngle(Vector a,Vector b){
|
||||
double tempa=Angle(a,Vector(1,0));
|
||||
if(a.y<0) tempa=2*PI-tempa;
|
||||
double tempb=Angle(b,Vector(1,0));
|
||||
if(b.y<0) tempb=2*PI-tempb;
|
||||
if((tempa-tempb)>0) return tempa-tempb;
|
||||
else return tempa-tempb+2*PI;
|
||||
}
|
||||
Vector Rotate(Vector a,double rad){
|
||||
return Vector(a.x*cos(rad)-a.y*sin(rad),a.x*sin(rad)+a.y*cos(rad));
|
||||
}
|
||||
Vector Normal(Vector a){
|
||||
double L=Length(a);
|
||||
return Vector(-a.y/L,a.x/L);
|
||||
}
|
||||
Point GetLineProjection(Point p,Point a,Point b){
|
||||
Vector v=b-a;
|
||||
return a+v*(Dot(v,p-a)/Dot(v,v));
|
||||
}
|
||||
Point GetLineIntersection(Point p,Vector v,Point q,Vector w){
|
||||
Vector u=p-q;
|
||||
double t=Cross(w,u)/Cross(v,w);
|
||||
return p+v*t;
|
||||
}
|
||||
int ConvexHull(Point* p,int n,Point* ch){
|
||||
sort(p,p+n);
|
||||
int m=0;
|
||||
for(int i=0;i<n;i++){
|
||||
while(m>1&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])<=0) m--;
|
||||
ch[m++]=p[i];
|
||||
}
|
||||
int k=m;
|
||||
for(int i=n-2;i>=0;i--){
|
||||
while(m>k&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])<=0) m--;
|
||||
ch[m++]=p[i];
|
||||
}
|
||||
if(n>0) m--;
|
||||
return m;
|
||||
}
|
||||
double Heron(double a,double b,double c){
|
||||
double p=(a+b+c)/2;
|
||||
return sqrt(p*(p-a)*(p-b)*(p-c));
|
||||
}
|
||||
bool SegmentProperIntersection(Point a1,Point a2,Point b1,Point b2){
|
||||
double c1=Cross(a2-a1,b1-a1),c2=Cross(a2-a1,b2-a1);
|
||||
double c3=Cross(b2-b1,a1-b1),c4=Cross(b2-b1,a2-b1);
|
||||
return doublecmp(c1)*doublecmp(c2)<0&&doublecmp(c3)*doublecmp(c4)<0;
|
||||
}
|
||||
double CutConvex(const int n,Point* poly, const Point a,const Point b, vector<Point> result[3]){
|
||||
vector<Point> points;
|
||||
Point p;
|
||||
Point p1=a,p2=b;
|
||||
int cur,pre;
|
||||
result[0].clear();
|
||||
result[1].clear();
|
||||
result[2].clear();
|
||||
if(n==0) return 0;
|
||||
double tempcross;
|
||||
tempcross=Cross(p2-p1,poly[0]-p1);
|
||||
if(doublecmp(tempcross)==0) pre=cur=2;
|
||||
else if(tempcross>0) pre=cur=0;
|
||||
else pre=cur=1;
|
||||
for(int i=0;i<n;i++){
|
||||
tempcross=Cross(p2-p1,poly[(i+1)%n]-p1);
|
||||
if(doublecmp(tempcross)==0) cur=2;
|
||||
else if(tempcross>0) cur=0;
|
||||
else cur=1;
|
||||
if(cur==pre){
|
||||
result[cur].push_back(poly[(i+1)%n]);
|
||||
}
|
||||
else{
|
||||
p1=poly[i];
|
||||
p2=poly[(i+1)%n];
|
||||
p=GetLineIntersection(p1,p2-p1,a,b-a);
|
||||
points.push_back(p);
|
||||
result[pre].push_back(p);
|
||||
result[cur].push_back(p);
|
||||
result[cur].push_back(poly[(i+1)%n]);
|
||||
pre=cur;
|
||||
}
|
||||
}
|
||||
sort(points.begin(),points.end());
|
||||
if(points.size()<2){
|
||||
return 0;
|
||||
}
|
||||
else{
|
||||
return Length(points.front()-points.back());
|
||||
}
|
||||
}
|
||||
double DistanceToSegment(Point p,Segment s){
|
||||
if(s.a==s.b) return Length(p-s.a);
|
||||
Vector v1=s.b-s.a,v2=p-s.a,v3=p-s.b;
|
||||
if(doublecmp(Dot(v1,v2))<0) return Length(v2);
|
||||
else if(doublecmp(Dot(v1,v3))>0) return Length(v3);
|
||||
else return fabs(Cross(v1,v2))/Length(v1);
|
||||
}
|
||||
bool isPointOnSegment(Point p,Segment s){
|
||||
return doublecmp(DistanceToSegment(p,s))==0;
|
||||
}
|
||||
int isPointInPolygon(Point p, Point* poly,int n){
|
||||
int wn=0;
|
||||
for(int i=0;i<n;i++){
|
||||
Point& p2=poly[(i+1)%n];
|
||||
if(isPointOnSegment(p,Segment(poly[i],p2))) return -1;
|
||||
int k=doublecmp(Cross(p2-poly[i],p-poly[i]));
|
||||
int d1=doublecmp(poly[i].y-p.y);
|
||||
int d2=doublecmp(p2.y-p.y);
|
||||
if(k>0&&d1<=0&&d2>0)wn++;
|
||||
if(k<0&&d2<=0&&d1>0)wn--;
|
||||
}
|
||||
if(wn) return 1;
|
||||
else return 0;
|
||||
}
|
||||
double PolygonArea(vector<Point> p){
|
||||
double area=0;
|
||||
int n=p.size();
|
||||
for(int i=1;i<n-1;i++)
|
||||
area+=Cross(p[i]-p[0],p[i+1]-p[0]);
|
||||
return area/2;
|
||||
}
|
||||
int PSLGtoPolygons(Segment arr[],int n,vector<Point>* Polygons){
|
||||
int count=n-1;
|
||||
bool vis[9999];memset(vis,0,sizeof vis);
|
||||
Point star=arr[0].a,pre=arr[0].a,cur=arr[0].b,purpose=arr[0].b;vis[0]=true;
|
||||
int mark;
|
||||
while(purpose!=star){
|
||||
double theta=-INF;
|
||||
for(int i=0;i<n;i++)if(!vis[i]&&arr[i].a==cur&&arr[i].b!=pre){
|
||||
if(theta<GetRerotateAngle(pre-cur,arr[i].b-cur)){
|
||||
theta=GetRerotateAngle(pre-cur,arr[i].b-cur);
|
||||
purpose=arr[i].b;
|
||||
mark=i;
|
||||
}
|
||||
}
|
||||
vis[mark]=true;count--;
|
||||
pre=cur;cur=purpose;
|
||||
}
|
||||
int polyidx=0;
|
||||
while(count>0){
|
||||
for(int i=0;i<n;i++)if(!vis[i]){
|
||||
star=arr[i].a,pre=arr[i].a,cur=arr[i].b,purpose=arr[i].b;vis[i]=true;count--;
|
||||
Polygons[polyidx].clear();
|
||||
Polygons[polyidx].push_back(cur);
|
||||
break;
|
||||
}
|
||||
while(purpose!=star){
|
||||
double theta=-INF;
|
||||
for(int i=0;i<n;i++)if(!vis[i]&&arr[i].a==cur&&arr[i].b!=pre){
|
||||
if(theta<GetRerotateAngle(pre-cur,arr[i].b-cur)){
|
||||
theta=GetRerotateAngle(pre-cur,arr[i].b-cur);
|
||||
purpose=arr[i].b;
|
||||
mark=i;
|
||||
}
|
||||
}
|
||||
vis[mark]=true;count--;
|
||||
Polygons[polyidx].push_back(purpose);
|
||||
pre=cur;cur=purpose;
|
||||
}
|
||||
polyidx++;
|
||||
}
|
||||
return polyidx;
|
||||
}
|
||||
int GetLineCircleIntersection(Line L,Circle C,Point& p1,Point& p2){
|
||||
double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y-C.c.y;
|
||||
double e = a*a + c*c, f = 2*(a*b+c*d), g = b*b + d*d -C.r*C.r;
|
||||
double delta = f*f - 4*e*g;
|
||||
if(doublecmp(delta) < 0) return 0;
|
||||
if(doublecmp(delta) == 0) {
|
||||
p1=p1=C.point(-f/(2*e));
|
||||
return 1;
|
||||
}
|
||||
p1=(L.p+L.v*(-f-sqrt(delta))/(2*e));
|
||||
p2=(L.p+L.v*(-f+sqrt(delta))/(2*e));
|
||||
return 2;
|
||||
}
|
||||
struct Allpoint{
|
||||
Point p;
|
||||
int pos;
|
||||
bool friend operator<(Allpoint a,Allpoint b){
|
||||
if(a.pos==-1&&a.pos==b.pos) return a.p<b.p;
|
||||
else if(a.pos==-1) return true;
|
||||
else if(b.pos==-1) return false;
|
||||
else return a.p<b.p;
|
||||
}
|
||||
}allpoint[8000];
|
||||
int idx=0;
|
||||
int lpint(Line l, Point a, Point b, Point c, Allpoint *sol) {
|
||||
int ret = 0;
|
||||
if (doublecmp(Cross(l.v, a - b)) != 0) {
|
||||
sol[ret].p = GetLineIntersection(l.p,l.v, a, b-a);
|
||||
if (isPointOnSegment(sol[ret].p, Segment(a, b))) ret++;
|
||||
}
|
||||
if (doublecmp(Cross(l.v, c - b)) != 0) {
|
||||
sol[ret].p = GetLineIntersection(l.p,l.v,c, b-c);
|
||||
if (isPointOnSegment(sol[ret].p, Segment(c, b))) ret++;
|
||||
}
|
||||
if (doublecmp(Cross(l.v, a - c)) != 0) {
|
||||
sol[ret].p = GetLineIntersection(l.p,l.v, a, c-a);
|
||||
if (isPointOnSegment(sol[ret].p, Segment(a, c))) ret++;
|
||||
}
|
||||
if (ret < 2) return 0;
|
||||
sort(sol, sol + ret);
|
||||
if (ret == 3) {
|
||||
if (sol[0].p == sol[1].p) sol[1].p = sol[2].p;
|
||||
}
|
||||
if (sol[0].p == sol[1].p) return 0;
|
||||
return 2;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,cas=1;
|
||||
scanf("%d",&T);
|
||||
while(T--){
|
||||
double v1,v2,v,t,x;
|
||||
int n;
|
||||
idx=0;
|
||||
scanf("%lf%lf%lf%lf%lf",&v1,&v2,&v,&t,&x);
|
||||
scanf("%d",&n);
|
||||
double time = v2 * t / (v2 - v1);
|
||||
Line l = Line(Point(x, 0), Point(x - v1 * time, v * time)-Point(x,0));
|
||||
for(int i=0;i<n;i++){
|
||||
Point O;
|
||||
double r,h;
|
||||
Allpoint ip[4];
|
||||
scanf("%lf%lf%lf%lf", &O.x, &O.y, &r, &h);
|
||||
int ipp = lpint(l, Point(O.x + r, O.y), Point(O.x - r, O.y), Point(O.x, O.y + h), ip);
|
||||
if (ipp) {
|
||||
if (ip[1] < ip[0]) swap(ip[0], ip[1]);
|
||||
for (int i = 0; i < 2; i++) ip[i].pos= i & 1, allpoint[idx++] = ip[i];
|
||||
}
|
||||
int ipc = GetLineCircleIntersection(l,Circle(O, r), ip[0].p,ip[1].p);
|
||||
if (ipc==2) {
|
||||
if (ip[1] < ip[0]) swap(ip[0], ip[1]);
|
||||
if (doublecmp(ip[1].p.y - O.y) >= 0) continue;
|
||||
if (doublecmp(ip[0].p.y - O.y) > 0) ip[0].p = GetLineIntersection(l.p,l.v, O, Point(1.0, 0));
|
||||
for (int i = 0; i < 2; i++) ip[i].pos = i & 1, allpoint[idx++] = ip[i];
|
||||
}
|
||||
}
|
||||
sort(allpoint, allpoint + idx);
|
||||
int cnt = 0;
|
||||
double sum = 0, lp = x - v1 * time, rp = x, ls = lp;
|
||||
for (int i = 0; i < idx; i++) {
|
||||
if (allpoint[i].p.x > rp) break;
|
||||
if (allpoint[i].p.x < lp) {
|
||||
if (allpoint[i].pos) cnt--;
|
||||
else cnt++;
|
||||
} else {
|
||||
if (allpoint[i].pos) {
|
||||
if (cnt == 1) sum += allpoint[i].p.x - ls;
|
||||
cnt--;
|
||||
} else {
|
||||
if (cnt == 0) ls = allpoint[i].p.x;
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cnt > 0) sum += rp - ls;
|
||||
printf("Case %d: %.4f\n", cas++, sum / v1);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
#include<iostream>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cstdlib>
|
||||
#include<cstdio>
|
||||
#include<set>
|
||||
#include<map>
|
||||
#include<vector>
|
||||
#include<cstring>
|
||||
#include<stack>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define CL(x,v); memset(x,v,sizeof(x));
|
||||
#define INF 0x3f3f3f3f
|
||||
#define LL long long
|
||||
#define REP(i,r,n) for(int i=r;i<=n;i++)
|
||||
#define RREP(i,n,r) for(int i=n;i>=r;i--)
|
||||
const int MAXN=1e5+100;
|
||||
int tree[MAXN];
|
||||
int n;
|
||||
int lowbit(int x)
|
||||
{
|
||||
return x&(-x);
|
||||
}
|
||||
void add(int pos,int val)
|
||||
{
|
||||
while(pos <=n)
|
||||
{
|
||||
tree[pos] += val;
|
||||
pos += lowbit(pos);
|
||||
}
|
||||
}
|
||||
int read(int x)
|
||||
{
|
||||
int s=0;
|
||||
while(x>0)
|
||||
{
|
||||
s += tree[x];
|
||||
x -= lowbit(x);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int A[MAXN],pos[MAXN];
|
||||
struct node{
|
||||
int l,r,index;
|
||||
bool operator <(const node& rsh)const{
|
||||
if(r==rsh.r)
|
||||
return l<rsh.l;
|
||||
else return r<rsh.r;
|
||||
}
|
||||
};
|
||||
vector<node> Q;
|
||||
int ans[MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int m;
|
||||
scanf("%d%d",&n,&m);
|
||||
REP(i,1,n){
|
||||
scanf("%d",&A[i]);
|
||||
pos[A[i]]=i;
|
||||
}
|
||||
Q.clear();
|
||||
node tmp;
|
||||
REP(i,1,m)
|
||||
{
|
||||
scanf("%d%d",&tmp.l,&tmp.r);
|
||||
tmp.index=i;
|
||||
Q.push_back(tmp);
|
||||
}
|
||||
sort(Q.begin(),Q.end());
|
||||
CL(tree,0);
|
||||
int j=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
add(i,1);
|
||||
if(A[i]+1<=n&&pos[A[i]+1]<i)
|
||||
{
|
||||
add(pos[A[i]+1],-1);
|
||||
}
|
||||
if(A[i]-1>=1&&pos[A[i]-1]<i)
|
||||
{
|
||||
add(pos[A[i]-1],-1);
|
||||
}
|
||||
while(Q[j].r==i)
|
||||
{
|
||||
ans[Q[j].index]=read(Q[j].r)-read(Q[j].l-1);
|
||||
j++;
|
||||
}
|
||||
}
|
||||
REP(i,1,m)
|
||||
{
|
||||
printf("%d\n",ans[i]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const int V = 5050 + 50;
|
||||
const int MaxN = 500 + 5;
|
||||
const int mod = 10000 + 7;
|
||||
int T, ans, num[V];
|
||||
char ch[10100];
|
||||
int main() {
|
||||
int i, j, k;
|
||||
scanf("%d", &T);
|
||||
num[0] = num[1] = 1;
|
||||
for(i = 2; i <= V; ++i)
|
||||
num[i] = (num[i - 1] + num[i - 2]) % mod;
|
||||
for(i = 1; i <= T; ++i) {
|
||||
ans = 1;
|
||||
int sum = 0;
|
||||
scanf("%s", &ch);
|
||||
int len = strlen(ch);
|
||||
for(j = 1; j < len; ++j) {
|
||||
if(ch[j] == 'e' && ch[j - 1] == 'h') {
|
||||
sum++;
|
||||
j++;
|
||||
}
|
||||
else {
|
||||
ans = (ans * num[sum]) % mod;
|
||||
sum = 0;
|
||||
}
|
||||
}
|
||||
ans = (ans * num[sum]) % mod;
|
||||
printf("Case %d: %d\n", i, ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define INF 2000000000
|
||||
int q[4*(1<<17)][2];
|
||||
int maxQ=4*(1<<17)-3;
|
||||
int front,rear,n,m;
|
||||
int mat[20][20];
|
||||
int dp[1<<17],f[1<<17],dist[1<<17][18],vis[1<<17][18];
|
||||
int main ()
|
||||
{
|
||||
int T;scanf("%d",&T);
|
||||
for(int kk=1;kk<=T;++kk)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
memset(dist,127,sizeof(dist));
|
||||
memset(dp,127,sizeof(dp));
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(mat,127,sizeof(mat));
|
||||
front=rear=0;
|
||||
int u,v,s;
|
||||
for(int i=1;i<=m;++i)
|
||||
{
|
||||
scanf("%d%d%d",&u,&v,&s);
|
||||
u--;v--;
|
||||
if(mat[u][v]>s)
|
||||
mat[u][v]=mat[v][u]=s;
|
||||
}
|
||||
dist[0][0]=0;
|
||||
q[++rear][0]=0;q[rear][1]=0;
|
||||
vis[0][0]=1;
|
||||
while(front!=rear)
|
||||
{
|
||||
if(++front==maxQ) front=0;
|
||||
int u_sta=q[front][0],u=q[front][1];
|
||||
vis[u_sta][u]=0;
|
||||
for(int i=0;i<n;++i)
|
||||
{
|
||||
int v_sta=u_sta|(1<<i);
|
||||
if(dist[v_sta][i]>dist[u_sta][u]+mat[u][i])
|
||||
{
|
||||
dist[v_sta][i]=dist[u_sta][u]+mat[u][i];
|
||||
if(!vis[v_sta][i])
|
||||
{
|
||||
if(++rear==maxQ) rear=0;
|
||||
vis[v_sta][i]=1;
|
||||
q[rear][0]=v_sta;q[rear][1]=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=0;i<(1<<n);++i)
|
||||
for(int j=0;j<n;++j)
|
||||
dp[i>>1]=min(dp[i>>1],dist[i][j]);
|
||||
int tot_sta=1<<n-1;
|
||||
for(int i=0;i<tot_sta;++i)
|
||||
f[i]=dp[i];
|
||||
for(int k=1;k<=2;++k)
|
||||
{
|
||||
for(int i=tot_sta-1;i;--i)
|
||||
for(u=i;u;u=(--u)&i)
|
||||
{
|
||||
v=i^u;
|
||||
if(dp[i]>max(dp[u],f[v]))
|
||||
{
|
||||
if(i==224 && max(dp[u],f[v])==5)
|
||||
cout<<"dd";
|
||||
dp[i]=max(dp[u],f[v]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int query;scanf("%d",&query);
|
||||
int sta=0;
|
||||
while(query--)
|
||||
{
|
||||
scanf("%d",&u);
|
||||
sta|=1<<u-2;
|
||||
}
|
||||
int ans=INF;
|
||||
for(int i=0;i<tot_sta;++i)
|
||||
if((i&sta)==sta)
|
||||
{
|
||||
ans=min(ans,dp[i]);
|
||||
}
|
||||
if(ans>=INF)
|
||||
printf("Case %d: -1\n",kk);
|
||||
else printf("Case %d: %d\n",kk,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define Maxn 250009
|
||||
int root,last;
|
||||
int tots;
|
||||
int l;
|
||||
int sv[Maxn*2];
|
||||
struct query{int a;long long ans;}qu[Maxn];
|
||||
struct sam_node{
|
||||
int fa,son[26];
|
||||
int len;
|
||||
void init(int _len){len=_len;fa=-1;memset(son,-1,sizeof(son));}
|
||||
}t[Maxn*2];
|
||||
void sam_init(){
|
||||
tots=0;
|
||||
root=last=0;
|
||||
t[tots].init(0);
|
||||
}
|
||||
void extend(int w){
|
||||
int p=last;
|
||||
int np=++tots;t[tots].init(t[p].len+1);
|
||||
sv[l]=np;
|
||||
int q,nq;
|
||||
while(p!=-1&&t[p].son[w]==-1){t[p].son[w]=np;p=t[p].fa;}
|
||||
if (p==-1) t[np].fa=root;
|
||||
else{
|
||||
q=t[p].son[w];
|
||||
if (t[p].len+1==t[q].len){t[np].fa=q;}
|
||||
else{
|
||||
nq=++tots;t[nq].init(0);
|
||||
t[nq]=t[q];
|
||||
t[nq].len=t[p].len+1;
|
||||
t[q].fa=nq;t[np].fa=nq;
|
||||
while(p!=-1&&t[p].son[w]==q){t[p].son[w]=nq;p=t[p].fa;}
|
||||
}
|
||||
}
|
||||
last=np;
|
||||
}
|
||||
int w[Maxn],r[Maxn*2];
|
||||
void topsort(){
|
||||
int i;
|
||||
for(i=0;i<=l;++i) w[i]=0;
|
||||
for(i=1;i<=tots;++i)w[t[i].len]++;
|
||||
for(i=1;i<=l;++i) w[i]+=w[i-1];
|
||||
for(i=tots;i>=1;--i)r[w[t[i].len]--]=i;
|
||||
r[0]=0;
|
||||
}
|
||||
int dp[Maxn*2];
|
||||
int sub[Maxn*2];
|
||||
char s[Maxn];
|
||||
int set[Maxn*2];
|
||||
int findset(int x){
|
||||
int y;
|
||||
while(x!=set[x]){
|
||||
y=set[x];
|
||||
set[x]=set[y];
|
||||
x=y;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
int main(){
|
||||
int n,m,k,f,y,p,i,a;
|
||||
long long ans;
|
||||
while(scanf("%d%d%d",&n,&m,&k)!=EOF){
|
||||
scanf("%s",s);
|
||||
int tl=strlen(s);
|
||||
l=0;
|
||||
sam_init();
|
||||
for(i=0;i<tl;++i){
|
||||
++l;
|
||||
extend(s[i]-'a');
|
||||
}
|
||||
char ts[20];
|
||||
for(i=1;i<=m;++i){
|
||||
scanf("%d",&a);
|
||||
if (a==1){
|
||||
scanf("%s",ts);
|
||||
s[l++]=ts[0];
|
||||
qu[i].a=a;
|
||||
extend(ts[0]-'a');
|
||||
}
|
||||
else if (a==2) qu[i].a=a;
|
||||
}
|
||||
for(i=0;i<=tots;++i){dp[i]=0;}
|
||||
topsort();
|
||||
p=root;
|
||||
for(i=0;i<l;++i){
|
||||
p=t[p].son[s[i]-'a'];
|
||||
dp[p]++;
|
||||
}
|
||||
for(i=tots;i>=1;--i){
|
||||
p=r[i];
|
||||
if (t[p].fa!=-1) dp[t[p].fa]+=dp[p];
|
||||
}
|
||||
ans=0;
|
||||
for(i=1;i<=tots;++i)
|
||||
if (dp[i]>=k) ans+=t[i].len-t[t[i].fa].len;
|
||||
for(i=0;i<=tots;++i){set[i]=i;sub[i]=0;}
|
||||
for(i=m;i>=1;--i){
|
||||
if (qu[i].a==2) qu[i].ans=ans;
|
||||
else{
|
||||
p=sv[l];
|
||||
l--;
|
||||
y=findset(p);
|
||||
while(y!=0&&dp[y]<k){
|
||||
f=t[y].fa;
|
||||
set[y]=f=findset(f);
|
||||
y=f;
|
||||
}
|
||||
y=findset(p);
|
||||
if (y==root) {continue;}
|
||||
sub[y]++;
|
||||
while(y!=0&&(dp[y]-sub[y]<k)){
|
||||
ans=ans-t[y].len+t[t[y].fa].len;
|
||||
f=t[y].fa;
|
||||
f=findset(f);
|
||||
sub[f]+=sub[y];
|
||||
set[y]=f;
|
||||
y=f;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i=1;i<=m;++i)if (qu[i].a==2){
|
||||
printf("%I64d\n",qu[i].ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int n,m;
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d%d",&n,&m);
|
||||
int x;
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<m;j++)
|
||||
scanf("%d",&x);
|
||||
if(x)
|
||||
puts("Alice");
|
||||
else
|
||||
puts("Bob");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,190 @@
|
|||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
const double eps=1e-11;
|
||||
struct point
|
||||
{
|
||||
double x,y;
|
||||
}city[55],base[55];
|
||||
int N,M,K,a,b;
|
||||
struct node
|
||||
{
|
||||
int i,j;
|
||||
point p;
|
||||
double dist;
|
||||
}jiao[3000];
|
||||
inline bool mo_ee(double x,double y)
|
||||
{
|
||||
double ret=x-y;
|
||||
if(ret<0) ret=-ret;
|
||||
if(ret<eps) return 1;
|
||||
return 0;
|
||||
}
|
||||
inline bool mo_gg(double x,double y) { return x > y + eps;} // x > y
|
||||
inline bool mo_ll(double x,double y) { return x < y - eps;} // x < y
|
||||
inline bool mo_ge(double x,double y) { return x > y - eps;} // x >= y
|
||||
inline bool mo_le(double x,double y) { return x < y + eps;} // x <= y
|
||||
inline double min(double a,double b)
|
||||
{
|
||||
if(a<b) return a;
|
||||
return b;
|
||||
}
|
||||
inline double max(double a,double b)
|
||||
{
|
||||
if(a>b) return a;
|
||||
return b;
|
||||
}
|
||||
point getxiang(point xiang)
|
||||
{
|
||||
point a;
|
||||
if(mo_ee(xiang.x,0))
|
||||
{
|
||||
a.x=1;
|
||||
a.y=0;
|
||||
return a;
|
||||
}else if(mo_ee(xiang.y,0))
|
||||
{
|
||||
a.x=0;
|
||||
a.y=1;
|
||||
return a;
|
||||
}else
|
||||
{
|
||||
a.x=1;
|
||||
a.y=-1.0*xiang.x/xiang.y;
|
||||
return a;
|
||||
}
|
||||
}
|
||||
inline double mo_distance(point p1,point p2)
|
||||
{
|
||||
return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
|
||||
}
|
||||
point mo_intersection(point u1,point u2,point v1,point v2)
|
||||
{
|
||||
point ret=u1;
|
||||
double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))
|
||||
/((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
|
||||
ret.x+=(u2.x-u1.x)*t;
|
||||
ret.y+=(u2.y-u1.y)*t;
|
||||
return ret;
|
||||
}
|
||||
int segjiao(point &ji,point a,point b,point c,point d)
|
||||
{
|
||||
ji=mo_intersection(a,b,c,d);
|
||||
if(mo_ll(ji.x,min(c.x,d.x))) return 0;
|
||||
if(mo_ll(ji.y,min(c.y,d.y))) return 0;
|
||||
if(mo_gg(ji.x,max(c.x,d.x))) return 0;
|
||||
if(mo_gg(ji.y,max(c.y,d.y))) return 0;
|
||||
return 1;
|
||||
}
|
||||
node jiaojiao(int a,int b,int ii,int jj)
|
||||
{
|
||||
node cur;
|
||||
point xiang1,xiang2;
|
||||
xiang1.x=city[b].x-city[a].x,xiang1.y=city[b].y-city[a].y;
|
||||
xiang2.x=base[jj].x-base[ii].x,xiang2.y=base[jj].y-base[ii].y;
|
||||
if(mo_ee(xiang1.x*xiang2.x,xiang1.y*xiang2.y))
|
||||
{
|
||||
cur.i=-1;
|
||||
return cur;
|
||||
}
|
||||
xiang2=getxiang(xiang2);
|
||||
point zhong;
|
||||
zhong.x=(base[ii].x+base[jj].x)/2,zhong.y=(base[ii].y+base[jj].y)/2;
|
||||
point zhongxia;
|
||||
zhongxia.x=zhong.x+xiang2.x;
|
||||
zhongxia.y=zhong.y+xiang2.y;
|
||||
point jiaodian;
|
||||
int jjao=segjiao(jiaodian,zhong,zhongxia,city[a],city[b]);
|
||||
if(jjao==0)
|
||||
{
|
||||
cur.i=-1;
|
||||
return cur;
|
||||
}
|
||||
cur.p=jiaodian;
|
||||
cur.i=ii;
|
||||
cur.j=jj;
|
||||
cur.dist=mo_distance(jiaodian,city[a]);
|
||||
return cur;
|
||||
}
|
||||
bool cmp(const node &aa,const node &bb)
|
||||
{
|
||||
if(mo_ee(aa.dist,bb.dist))
|
||||
{
|
||||
point temp;
|
||||
temp.x=(base[aa.i].x+base[aa.j].x)/2;
|
||||
temp.y=(base[aa.i].y+base[aa.j].y)/2;
|
||||
double dist1=mo_distance(aa.p,temp);
|
||||
temp.x=(base[bb.i].x+base[bb.j].x)/2;
|
||||
temp.y=(base[bb.i].y+base[bb.j].y)/2;
|
||||
double dist2=mo_distance(bb.p,temp);
|
||||
return mo_ll(dist1,dist2);
|
||||
}
|
||||
return mo_ll(aa.dist,bb.dist);
|
||||
}
|
||||
inline int nextno(int j,int no)
|
||||
{
|
||||
if(jiao[j].i==no) return jiao[j].j;
|
||||
if(jiao[j].j==no) return jiao[j].i;
|
||||
return no;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,ncase;
|
||||
while(scanf("%d%d",&N,&M)!=EOF)
|
||||
{
|
||||
for(i=1;i<=N;++i)
|
||||
{
|
||||
scanf("%lf%lf",&city[i].x,&city[i].y);
|
||||
}
|
||||
for(i=1;i<=M;++i)
|
||||
{
|
||||
scanf("%lf%lf",&base[i].x,&base[i].y);
|
||||
}
|
||||
scanf("%d",&K);
|
||||
for(ncase=0;ncase<K;++ncase)
|
||||
{
|
||||
int yong=0;
|
||||
scanf("%d%d",&a,&b);
|
||||
for(i=1;i<=M;++i)
|
||||
{
|
||||
for(j=i+1;j<=M;++j)
|
||||
{
|
||||
if(i==j) continue;
|
||||
node cur=jiaojiao(a,b,i,j);
|
||||
if(cur.i<0)
|
||||
{
|
||||
continue;
|
||||
}else
|
||||
{
|
||||
jiao[yong++]=cur;
|
||||
}
|
||||
}
|
||||
}
|
||||
sort(jiao,jiao+yong,cmp);
|
||||
double mindist=-1;
|
||||
int minno;
|
||||
for(i=1;i<=M;++i)
|
||||
{
|
||||
double disttemp=sqrt((city[a].x-base[i].x)*(city[a].x-base[i].x)+(city[a].y-base[i].y)*(city[a].y-base[i].y));
|
||||
if(mindist<0||mo_ll(disttemp,mindist))
|
||||
{
|
||||
mindist=disttemp;
|
||||
minno=i;
|
||||
}
|
||||
}
|
||||
int dang=minno,ret=0;
|
||||
for(i=0;i<yong;++i)
|
||||
{
|
||||
int xinno=nextno(i,dang);
|
||||
if(xinno!=dang)
|
||||
{
|
||||
dang=xinno;
|
||||
ret++;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ret);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
char str[2000100];
|
||||
char t[100100];
|
||||
pair<int,int>s[100100];
|
||||
int index[100100];
|
||||
int n;
|
||||
int ne[100100];
|
||||
void get_next(char* str,int len){
|
||||
ne[0]=0;
|
||||
for(int i=1;i<len;i++){
|
||||
int j=ne[i-1];
|
||||
while(j&&str[i]!=str[j])j=ne[j-1];
|
||||
if(str[i]==str[j])j++;
|
||||
ne[i]=j;
|
||||
}
|
||||
}
|
||||
bool match(char *s,int len){
|
||||
int k=0;
|
||||
for(int i=0;i<n;i++){
|
||||
while(k&&str[k]!=s[i])k=ne[k-1];
|
||||
if(str[k]==s[i])k++;
|
||||
if(k==len)return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%s",str)){
|
||||
n=strlen(str);
|
||||
for(int i=0;i<n;i++){
|
||||
s[i].first=str[i];
|
||||
s[i].second=i;
|
||||
}
|
||||
stable_sort(s,s+n);
|
||||
for(int i=0;i<n;i++)index[i]=s[i].second;
|
||||
int now=index[0];
|
||||
n--;
|
||||
for(int i=0;i<n;i++){
|
||||
t[i]=s[now].first;
|
||||
now=index[now];
|
||||
}
|
||||
t[n]='\0';
|
||||
int q;
|
||||
scanf("%d",&q);
|
||||
while(q--){
|
||||
scanf("%s",str);
|
||||
int len=strlen(str);
|
||||
get_next(str,len);
|
||||
if(match(t,len))printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#define ll long long
|
||||
using namespace std;
|
||||
ll t,n;
|
||||
map<ll,ll> g;
|
||||
ll f(ll x)
|
||||
{
|
||||
if (x%2==0) return 2*(x/6+1)-1;
|
||||
else return 2*((x-3)/6+1);
|
||||
}
|
||||
ll get(ll x)
|
||||
{
|
||||
if (g[x]!=0) return g[x];
|
||||
g[x]=f(x);
|
||||
for (ll i=2; i*i<=x; i++)
|
||||
{
|
||||
if (x%i>0) continue;
|
||||
g[x]-=get(i);
|
||||
if (i*i!=x)
|
||||
{
|
||||
g[x]-=get(x/i);
|
||||
}
|
||||
}
|
||||
return g[x];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%I64d",&t);
|
||||
while (t--)
|
||||
{
|
||||
scanf("%I64d",&n);
|
||||
if (n%3==0)
|
||||
{
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
if ((n&1)==0)
|
||||
{
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
if (n==1)
|
||||
{
|
||||
printf("1\n");
|
||||
continue;
|
||||
}
|
||||
if (n==3)
|
||||
{
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
n=(n+3)>>1;
|
||||
printf("%I64d\n",get(n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int N=100010;
|
||||
int n,m;
|
||||
double a[N];
|
||||
int cmp(double x,double y){
|
||||
return x>y;
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%d%d",&n,&m)){
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%lf",&a[i]);
|
||||
int u,v,w;
|
||||
while(m--){
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
a[u]+=1.0*w/2;
|
||||
a[v]+=1.0*w/2;
|
||||
}
|
||||
double t1=0,t2=0;
|
||||
sort(a+1,a+1+n,cmp);
|
||||
for(int i=1;i<=n;i++)
|
||||
if(i&1)
|
||||
t1+=a[i];
|
||||
else
|
||||
t2+=a[i];
|
||||
printf("%.0lf\n",t1-t2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int V = 100000 + 50;
|
||||
const int MaxN = 80 + 5;
|
||||
const int mod = 10000 + 7;
|
||||
const __int64 INF = 0x7FFFFFFFFFFFFFFFLL;
|
||||
const int inf = 0x7fffffff;
|
||||
int n, m, sum[V], ans;
|
||||
int main() {
|
||||
int i, j;
|
||||
while(~scanf("%d%d", &n, &m)) {
|
||||
ans = 0;
|
||||
for(i = 1; i <= n; ++i) {
|
||||
int temp;
|
||||
scanf("%d", &temp);
|
||||
sum[i] = (sum[i - 1] + temp) % m;
|
||||
}
|
||||
for(i = n; i >= 1 && i > ans; --i) {
|
||||
for(j = 1; j + i - 1 <= n; ++j)
|
||||
if((sum[j + i - 1] - sum[j - 1]) % m == 0) {
|
||||
ans = max(ans, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <math.h>
|
||||
#include <bitset>
|
||||
#include <algorithm>
|
||||
#include <climits>
|
||||
using namespace std;
|
||||
#define ls 2*i
|
||||
#define rs 2*i+1
|
||||
#define UP(i,x,y) for(i=x;i<=y;i++)
|
||||
#define DOWN(i,x,y) for(i=x;i>=y;i--)
|
||||
#define MEM(a,x) memset(a,x,sizeof(a))
|
||||
#define W(a) while(a)
|
||||
#define gcd(a,b) __gcd(a,b)
|
||||
#define LL long long
|
||||
#define N 205
|
||||
#define MOD 1000000007
|
||||
#define INF 0x3f3f3f3f
|
||||
#define EXP 1e-8
|
||||
#define rank rank1
|
||||
const int mod = 10007;
|
||||
int n,a[N];
|
||||
double dp[N],p[N],ans;
|
||||
char op[N][5];
|
||||
int main()
|
||||
{
|
||||
int i,j,k,cas=1;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(i = 0; i<=n; i++)
|
||||
scanf("%d",&a[i]);
|
||||
for(i = 1; i<=n; i++)
|
||||
scanf("%s",op[i]);
|
||||
for(i = 1; i<=n; i++)
|
||||
scanf("%lf",&p[i]);
|
||||
ans = 0;
|
||||
for(i = 0; i<=20; i++)
|
||||
{
|
||||
double q;
|
||||
if(a[0]&(1<<i)) q = 1;
|
||||
else q = 0;
|
||||
for(j = 1; j<=n; j++)
|
||||
{
|
||||
if(a[j]&(1<<i))
|
||||
{
|
||||
if(op[j][0]=='&')
|
||||
continue;
|
||||
else if(op[j][0]=='^')
|
||||
q = q*p[j]+(1-q)*(1-p[j]);
|
||||
else
|
||||
q = q*p[j]+(1-p[j]);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(op[j][0]=='&')
|
||||
q = q*p[j];
|
||||
else
|
||||
continue;
|
||||
}
|
||||
}
|
||||
ans += q*(1<<i);
|
||||
}
|
||||
printf("Case %d:\n%lf\n",cas++,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int N = 101;
|
||||
const double INF = 10000000000.0;
|
||||
const int INF_INT =10000000;
|
||||
int side[N][N];
|
||||
int dis[N][N];
|
||||
int vis[N][N];
|
||||
int tmp[N][N];
|
||||
double ans[N][N];
|
||||
int main(){
|
||||
int n,m;
|
||||
while(~scanf("%d%d",&n,&m)){
|
||||
memset(vis,-1,sizeof(vis));
|
||||
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){ans[i][j]=INF;side[i][j]=INF_INT;}
|
||||
for(int i=0;i<m;i++){
|
||||
int u,v,w;
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
side[u][v]=w;
|
||||
vis[u][v]=1;
|
||||
}
|
||||
for(int k=1;k<=n;k++)for(int i=1;i<=n;i++)if(vis[i][k]!=-1){
|
||||
for(int j=1;j<=n;j++)if(vis[k][j]!=-1){
|
||||
if(vis[i][j]==-1)vis[i][j]=vis[i][k]+vis[k][j];
|
||||
else vis[i][j]=min(vis[i][j],vis[i][k]+vis[k][j]);
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)dis[i][j]=side[i][j];
|
||||
for(int k=1;k<=n;k++){
|
||||
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(vis[i][j]!=-1&&k>=vis[i][j]){
|
||||
ans[i][j]=min(ans[i][j],(double)dis[i][j]/k);
|
||||
}
|
||||
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){tmp[i][j]=dis[i][j];dis[i][j]=INF_INT;}
|
||||
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){
|
||||
for(int h=1;h<=n;h++){
|
||||
if(vis[i][h]==-1||k<vis[i][h])continue;
|
||||
if(vis[h][j]==-1||k<vis[h][j])continue;
|
||||
dis[i][j]=min(dis[i][j],tmp[i][h]+side[h][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(vis[i][j]!=-1){
|
||||
for(int k=1;k<=n;k++)if(vis[i][k]!=-1&&vis[k][j]!=-1&&vis[k][k]!=-1){
|
||||
ans[i][j]=min(ans[i][j],ans[k][k]);
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=n;i++){
|
||||
int j=1;
|
||||
if(vis[i][j]==-1)printf("NO");
|
||||
else printf("%.3lf",ans[i][j]);
|
||||
for(j=2;j<=n;j++){
|
||||
if(vis[i][j]==-1)printf(" NO");
|
||||
else printf(" %.3lf",ans[i][j]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
long long tar[100002];
|
||||
const int MOD=1000000007;
|
||||
void init()
|
||||
{
|
||||
memset(tar,0,sizeof(tar));
|
||||
tar[0]=1;
|
||||
for(int i=1;i<=100000;i++)
|
||||
{
|
||||
int nbit;
|
||||
for(int j=1;;j++)
|
||||
{
|
||||
int element1,element2;
|
||||
element1=i-j*(3*j-1)/2;
|
||||
element2=i-j*(3*j+1)/2;
|
||||
if(j&1)
|
||||
nbit=1;
|
||||
else if(j%2==0)
|
||||
nbit=-1;
|
||||
if(element2<0 && element1<0)
|
||||
break;
|
||||
if(element1>=0)
|
||||
{
|
||||
tar[i]=(tar[i]+nbit*tar[element1])%MOD;
|
||||
}
|
||||
if(element2>=0)
|
||||
{
|
||||
tar[i]=(tar[i]+nbit*tar[element2])%MOD;
|
||||
}
|
||||
}
|
||||
tar[i]=(tar[i]+MOD)%MOD;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int testcase;
|
||||
init();
|
||||
cin>>testcase;
|
||||
while(testcase--)
|
||||
{
|
||||
int rat;
|
||||
cin>>rat;
|
||||
cout<<tar[rat]<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
double solve0(int m,int n)
|
||||
{
|
||||
double ans=0;
|
||||
for(int i=0;i<=n-1;i++)
|
||||
ans+=pow(1.0*m,i);
|
||||
return ans;
|
||||
}
|
||||
double solve1(int m,int n)
|
||||
{
|
||||
double ans=0;
|
||||
double tmp=1;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
ans+=tmp;
|
||||
tmp*=(m+0.0)/(m-i);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
while(scanf("%d",&t)!=EOF)
|
||||
{
|
||||
while(t--)
|
||||
{
|
||||
int n,m,op;
|
||||
scanf("%d%d%d",&op,&m,&n);
|
||||
if(op==0)
|
||||
printf("%.9lf\n",solve0(m,n));
|
||||
else
|
||||
printf("%.9lf\n",solve1(m,n));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define inf (1<<29)
|
||||
const int maxn = 105;
|
||||
int g[maxn][maxn],a[maxn][maxn],p[maxn];
|
||||
bool vis[maxn],combine[maxn],par[maxn];
|
||||
int d[maxn],node[maxn],st[maxn],k,s,t;
|
||||
vector <int> vst[maxn];
|
||||
vector <int> pa , pb;
|
||||
int prim(int n) {
|
||||
memset(vis,0,sizeof(vis));
|
||||
memset(d,0,sizeof(d));
|
||||
int mincut = 0 , tmp = -1;
|
||||
s = t = -1;
|
||||
int top = 0;
|
||||
for(int i=0;i<k;i++) {
|
||||
int maxi = -inf;
|
||||
for(int j=0;j<k;j++) {
|
||||
int u = node[j];
|
||||
if(!combine[u]&&!vis[u]&&d[u]>maxi) {
|
||||
tmp = u;
|
||||
maxi = d[u];
|
||||
}
|
||||
}
|
||||
st[top++] = tmp;
|
||||
vis[tmp] = true;
|
||||
if(i == k-1)
|
||||
mincut = d[tmp];
|
||||
for(int j=0;j<k;j++) {
|
||||
int u = node[j];
|
||||
if(!combine[u]&&!vis[u])
|
||||
d[u] += g[tmp][u];
|
||||
}
|
||||
}
|
||||
s = st[top-2];
|
||||
t = st[top-1];
|
||||
for(int i=0;i<top;i++) node[i] = st[i];
|
||||
return mincut;
|
||||
}
|
||||
int stoer_wagner(int n) {
|
||||
for(int i=0;i<n;i++) {
|
||||
vst[i].clear();
|
||||
vst[i].push_back(i);
|
||||
}
|
||||
int ans = inf;
|
||||
memset(combine,0,sizeof(combine));
|
||||
for(int i=0;i<n;i++) node[i] = i;
|
||||
for(int i=1;i<n;i++) {
|
||||
k = n - i + 1;
|
||||
int cur = prim(n);
|
||||
if(cur < ans) {
|
||||
ans = cur;
|
||||
for(int j=0;j<n;j++) par[j] = 0;
|
||||
for(int j=0;j<vst[t].size();j++) par[ vst[t][j] ] = 1;
|
||||
}
|
||||
combine[t] = true;
|
||||
for(int j=0;j<vst[t].size();j++) vst[s].push_back(vst[t][j]);
|
||||
for(int j=0;j<n;j++) {
|
||||
if(j == s) continue;
|
||||
if(!combine[j]) {
|
||||
g[s][j] += g[t][j];
|
||||
g[j][s] += g[j][t];
|
||||
}
|
||||
}
|
||||
}
|
||||
pa.clear(); pb.clear();
|
||||
for(int i=0;i<n;i++)
|
||||
if(par[i]) pa.push_back(i);
|
||||
else pb.push_back(i);
|
||||
return ans;
|
||||
}
|
||||
int K;
|
||||
int dfs(vector <int> t) {
|
||||
int n = t.size();
|
||||
for(int i=0;i<n;i++) for(int j=0;j<n;j++) g[i][j] = a[t[i]][t[j]];
|
||||
if(stoer_wagner(n) >= K) return 1;
|
||||
vector <int> x , y;
|
||||
for(int i=0;i<pa.size();i++) x.push_back(t[pa[i]]);
|
||||
for(int i=0;i<pb.size();i++) y.push_back(t[pb[i]]);
|
||||
return dfs(x) + dfs(y);
|
||||
}
|
||||
int main() {
|
||||
int n , m;
|
||||
while(~scanf("%d%d%d",&n,&m,&K)) {
|
||||
memset(a , 0 ,sizeof(a));
|
||||
while(m--) {
|
||||
int u , v;
|
||||
scanf("%d%d",&u,&v);
|
||||
u --; v --;
|
||||
a[u][v] += 1;
|
||||
a[v][u] += 1;
|
||||
}
|
||||
vector <int> t;
|
||||
for(int i=0;i<n;i++) t.push_back(i);
|
||||
printf("%d\n" , dfs(t));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
const int MOD = 1e9+7;
|
||||
long long inv(long long a,long long m)
|
||||
{
|
||||
if(a == 1)return 1;
|
||||
return inv(m%a,m)*(m-m/a)%m;
|
||||
}
|
||||
const int MAXN = 1000010;
|
||||
int a[MAXN];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int n;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
long long S = 1;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
S *= a[i];
|
||||
S %=MOD;
|
||||
}
|
||||
long long ans = S*n%MOD;
|
||||
sort(a,a+n);
|
||||
reverse(a,a+n);
|
||||
int cnt = n-1;
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
if(cnt == 0)break;
|
||||
long long tmp = S*inv(a[i],MOD)%MOD;
|
||||
ans -= tmp;
|
||||
ans = (ans%MOD+MOD)%MOD;
|
||||
cnt--;
|
||||
if(cnt == 0)break;
|
||||
ans -= tmp;
|
||||
ans = (ans%MOD+MOD)%MOD;
|
||||
cnt--;
|
||||
if(cnt == 0)break;
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#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 P = 1000003;
|
||||
const int N1 = 262144;
|
||||
const int N2 = N1+1;
|
||||
const int P1 = 998244353;
|
||||
const int P2 = 995622913;
|
||||
const int E1 = 996173970;
|
||||
const int E2 = 88560779;
|
||||
const int F1 = 121392023;
|
||||
const int F2 = 840835547;
|
||||
const int I1 = 998240545;
|
||||
const int I2 = 995619115;
|
||||
const long long M1 = 397550359381069386LL;
|
||||
const long long M2 = 596324591238590904LL;
|
||||
const long long MM = 993874950619660289LL;
|
||||
long long mul(long long x,long long y,long long z){
|
||||
return (x*y - (long long)(x/(long double)z*y+1e-3)*z+z)%z;
|
||||
}
|
||||
int trf(int x1,int x2){
|
||||
return (mul(M1,x1,MM)+mul(M2,x2,MM))%MM%P;
|
||||
}
|
||||
int A[N2],B[N2],C[N2];
|
||||
int A1[N2],B1[N2],C1[N2];
|
||||
void fft(int *A,int PM,int PW){
|
||||
for(int m = N1,h;h = m/2, m >= 2;PW = (long long)PW*PW%PM,m=h)
|
||||
for(int i = 0,w=1;i < h;i++, w = (long long)w*PW%PM)
|
||||
for(int j = i;j < N1;j += m){
|
||||
int k = j+h, x = (A[j]-A[k]+PM)%PM;
|
||||
(A[j]+=A[k])%=PM;
|
||||
A[k] = (long long)w*x%PM;
|
||||
}
|
||||
for(int i = 0,j = 1;j < N1-1;j++){
|
||||
for(int k = N1/2; k > (i^=k);k /= 2);
|
||||
if(j < i)swap(A[i],A[j]);
|
||||
}
|
||||
}
|
||||
void mul(){
|
||||
memset(C,0,sizeof(C));
|
||||
memcpy(A1,A,sizeof(A));
|
||||
memcpy(B1,B,sizeof(B));
|
||||
fft(A1,P1,E1); fft(B1,P1,E1);
|
||||
for(int i = 0;i < N1;i++)C1[i] = (long long)A1[i]*B1[i]%P1;
|
||||
fft(C1,P1,F1);
|
||||
for(int i = 0;i < N1;i++)C1[i] = (long long)C1[i]*I1%P1;
|
||||
fft(A,P2,E2); fft(B,P2,E2);
|
||||
for(int i = 0;i < N1;i++)C[i] = (long long)A[i]*B[i]%P2;
|
||||
fft(C,P2,F2);
|
||||
for(int i = 0;i < N1;i++)C[i] = (long long)C[i]*I2%P2;
|
||||
for(int i = 0;i < N1;i++)C[i] = trf(C1[i],C[i]);
|
||||
}
|
||||
int INV[P];
|
||||
const int MAXN = 100010;
|
||||
int F[MAXN];
|
||||
int a[MAXN];
|
||||
int pd[MAXN];
|
||||
int pb[MAXN];
|
||||
int pc2[MAXN];
|
||||
int p[MAXN];
|
||||
int main()
|
||||
{
|
||||
INV[1] = 1;
|
||||
for(int i = 2;i < P;i++)
|
||||
INV[i] = (long long)P/i*(P-INV[P%i])%P;
|
||||
F[0] = 1;
|
||||
for(int i = 1;i < MAXN;i++)
|
||||
F[i] = (long long)F[i-1]*i%P;
|
||||
int n,b,c,d;
|
||||
while(scanf("%d%d%d%d",&n,&b,&c,&d) == 4){
|
||||
for(int i = 0;i < n;i++)scanf("%d",&a[i]);
|
||||
pd[0] = 1;
|
||||
for(int i = 1;i < n;i++)
|
||||
pd[i] = (long long)pd[i-1]*d%P;
|
||||
memset(A,0,sizeof(A));
|
||||
memset(B,0,sizeof(B));
|
||||
for(int i = 0;i < n;i++)
|
||||
A[i] = (long long)a[n-1-i]*F[n-1-i]%P;
|
||||
for(int i = 0;i < n;i++)
|
||||
B[i] = (long long)pd[i]*INV[F[i]]%P;
|
||||
mul();
|
||||
for(int i = 0;i < n;i++)p[i] = C[i];
|
||||
reverse(p,p+n);
|
||||
memset(A,0,sizeof(A));
|
||||
pb[0] = 1;
|
||||
for(int i = 1;i < n;i++)
|
||||
pb[i] = (long long)pb[i-1]*b%P;
|
||||
pc2[0] = 1;
|
||||
int c2 = (long long)c*c%P;
|
||||
for(int i = 1, s = c;i < n;i++){
|
||||
pc2[i] = (long long)pc2[i-1]*s%P;
|
||||
s = (long long)s*c2%P;
|
||||
}
|
||||
for(int i = 0;i < n;i++)
|
||||
A[i] = (long long)pb[i]*INV[F[i]]%P*p[i]%P*pc2[i]%P;
|
||||
memset(B,0,sizeof(B));
|
||||
B[0] = 1;
|
||||
for(int i = 1;i < n;i++)
|
||||
B[i] = B[N1-i] = INV[pc2[i]];
|
||||
mul();
|
||||
for(int i = 0;i < n;i++)C[i] = (long long)C[i]*pc2[i]%P;
|
||||
for(int i = 0;i < n;i++)
|
||||
printf("%d\n",C[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#include<iomanip>
|
||||
#include<cmath>
|
||||
#include<ctime>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#define ll __int64
|
||||
#define pi acos(-1.0)
|
||||
#define MAX 100005
|
||||
#define mod 1000003
|
||||
using namespace std;
|
||||
int a[MAX],b[MAX],c[MAX],index[MAX];
|
||||
int main(){
|
||||
int t,n,i,j;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++) scanf("%d",&b[i]);
|
||||
for(i=0;i<n;i++) a[i]=c[i]=index[i]=i;
|
||||
for(i=0;i<n;i++){
|
||||
int cur=i;
|
||||
while((a[cur]+b[cur])%n!=c[cur]){
|
||||
int l = index[(c[cur]-b[cur]+n)%n];
|
||||
swap(a[l],a[cur]);
|
||||
swap(index[a[l]],index[a[cur]]);
|
||||
if(l>i) break;
|
||||
cur=l;
|
||||
swap(c[i+1],c[cur]);
|
||||
}
|
||||
}
|
||||
for(i=0;i<n;i++){
|
||||
printf("%d",a[i]);
|
||||
if(i!=n-1) printf(" ");
|
||||
else printf("\n");
|
||||
}
|
||||
for(i=0;i<n;i++){
|
||||
printf("%d",c[i]);
|
||||
if(i!=n-1) printf(" ");
|
||||
else printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int mod=1e9+7;
|
||||
int f[100010];
|
||||
void init()
|
||||
{
|
||||
f[0]=1;
|
||||
int i,j,k,flag,t,tt;
|
||||
for(i=1;i<=100000;i++)
|
||||
{
|
||||
f[i]=0;
|
||||
flag=1;
|
||||
for(j=1;;j++)
|
||||
{
|
||||
t=i-j*(3*j-1)/2;
|
||||
tt=i-j*(3*j+1)/2;
|
||||
if(t<0)break;
|
||||
f[i]=(f[i]+flag*f[t])%mod;
|
||||
if(tt<0)break;
|
||||
f[i]=(f[i]+flag*f[tt])%mod;
|
||||
flag=-flag;
|
||||
}
|
||||
f[i]=(f[i]+mod)%mod;
|
||||
}
|
||||
}
|
||||
int find(int n,int k)
|
||||
{
|
||||
int i,j,ans,flag=-1,t,tt;
|
||||
ans=f[n];
|
||||
for(i=1;;i++)
|
||||
{
|
||||
t=k*i*(i*3-1)/2;
|
||||
tt=k*i*(i*3+1)/2;
|
||||
if(t>n)break;
|
||||
ans=(ans+flag*f[n-t])%mod;
|
||||
if(tt>n)break;
|
||||
ans=(ans+flag*f[n-tt])%mod;
|
||||
flag=-flag;
|
||||
}
|
||||
return (ans+mod)%mod;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int T;
|
||||
cin>>T;
|
||||
while(T--)
|
||||
{
|
||||
int n,k,ans;
|
||||
scanf("%d%d",&n,&k);
|
||||
ans=find(n,k) ;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
typedef long long LL;
|
||||
#define MAXN 1000010
|
||||
#define MAXM 2000010
|
||||
#define MOD 1000000007
|
||||
int n;
|
||||
LL fac[MAXN];
|
||||
LL invfac[MAXN];
|
||||
int first[MAXN], next[MAXM], v[MAXM], e;
|
||||
bool vis[MAXN];
|
||||
LL dp[MAXN];
|
||||
LL f[MAXN];
|
||||
int size[MAXN];
|
||||
LL ext_gcd(LL a, LL b, LL &x, LL &y) {
|
||||
LL t, d;
|
||||
if (b == 0) {
|
||||
x = 1;
|
||||
y = 0;
|
||||
return a;
|
||||
}
|
||||
d = ext_gcd(b, a % b, x, y);
|
||||
t = x;
|
||||
x = y;
|
||||
y = t - a / b * y;
|
||||
return d;
|
||||
}
|
||||
LL invmod(LL a, LL n = MOD) {
|
||||
LL x, y;
|
||||
if (ext_gcd(a, n, x, y) != 1)
|
||||
return -1;
|
||||
return (x % n + n) % n;
|
||||
}
|
||||
void init() {
|
||||
int i;
|
||||
fac[0] = 1;
|
||||
for (i = 1; i < MAXN; i++) {
|
||||
fac[i] = fac[i - 1] * i;
|
||||
fac[i] %= MOD;
|
||||
}
|
||||
for (i = 0; i < MAXN; i++) {
|
||||
invfac[i] = invmod(fac[i]);
|
||||
}
|
||||
}
|
||||
inline void addEdge(int x, int y) {
|
||||
v[e] = y;
|
||||
next[e] = first[x];
|
||||
first[x] = e++;
|
||||
}
|
||||
void getSize(int x) {
|
||||
vis[x] = true;
|
||||
size[x] = 1;
|
||||
for (int i = first[x]; i != -1; i = next[i]) {
|
||||
int y = v[i];
|
||||
if (!vis[y]) {
|
||||
getSize(y);
|
||||
size[x] += size[y];
|
||||
}
|
||||
}
|
||||
}
|
||||
void dfs(int x) {
|
||||
vis[x] = true;
|
||||
dp[x] = fac[size[x] - 1];
|
||||
for (int i = first[x]; i != -1; i = next[i]) {
|
||||
int y = v[i];
|
||||
if (!vis[y]) {
|
||||
dfs(y);
|
||||
dp[x] *= invfac[size[y]];
|
||||
dp[x] %= MOD;
|
||||
dp[x] *= dp[y];
|
||||
dp[x] %= MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
void search(int x, int pre) {
|
||||
vis[x] = true;
|
||||
if (pre != -1) {
|
||||
f[x] = fac[n - 1];
|
||||
f[x] *= invfac[n - size[x]];
|
||||
f[x] %= MOD;
|
||||
LL tmp = f[pre];
|
||||
tmp *= invfac[n - 1];
|
||||
tmp %= MOD;
|
||||
tmp *= fac[n - 1 - size[x]];
|
||||
tmp %= MOD;
|
||||
tmp *= fac[size[x]];
|
||||
tmp %= MOD;
|
||||
tmp *= invmod(dp[x]);
|
||||
tmp %= MOD;
|
||||
f[x] *= tmp;
|
||||
f[x] %= MOD;
|
||||
for (int i = first[x]; i != -1; i = next[i]) {
|
||||
int y = v[i];
|
||||
if (!vis[y]) {
|
||||
f[x] *= invfac[size[y]];
|
||||
f[x] %= MOD;
|
||||
f[x] *= dp[y];
|
||||
f[x] %= MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = first[x]; i != -1; i = next[i]) {
|
||||
int y = v[i];
|
||||
if (!vis[y]) {
|
||||
search(y, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int T;
|
||||
int i;
|
||||
int x, y;
|
||||
int ans;
|
||||
init();
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d", &n);
|
||||
e = 0;
|
||||
memset(first, -1, sizeof(first));
|
||||
for (i = 1; i < n; i++) {
|
||||
scanf("%d%d", &x, &y);
|
||||
addEdge(x, y);
|
||||
addEdge(y, x);
|
||||
}
|
||||
memset(vis, false, sizeof(vis));
|
||||
getSize(1);
|
||||
memset(vis, false, sizeof(vis));
|
||||
dfs(1);
|
||||
memset(vis, false, sizeof(vis));
|
||||
f[1] = dp[1];
|
||||
search(1, -1);
|
||||
ans = 0;
|
||||
for (i = 1; i <= n; i++) {
|
||||
ans += (f[i] * f[i]) % MOD;
|
||||
ans %= MOD;
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#define MAXN 1000010
|
||||
char str[MAXN];
|
||||
bool isOK(int len) {
|
||||
if (str[0] != 'M') {
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < len; i++) {
|
||||
if (str[i] == 'M') {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
int main() {
|
||||
int T;
|
||||
int len;
|
||||
int cnt;
|
||||
int i;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf(" %s", str);
|
||||
len = strlen(str);
|
||||
if (isOK(len)) {
|
||||
cnt = 0;
|
||||
for (i = 1; i < len; i++) {
|
||||
if (str[i] == 'U') {
|
||||
cnt += 3;
|
||||
} else {
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
if (len == 2 && str[1] == 'I') {
|
||||
puts("Yes");
|
||||
} else if (cnt % 6 == 2 || cnt % 6 == 4) {
|
||||
puts("Yes");
|
||||
} else {
|
||||
puts("No");
|
||||
}
|
||||
} else {
|
||||
puts("No");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#define MAXN 1010
|
||||
int sg[MAXN];
|
||||
bool vis[MAXN];
|
||||
int SG(int n) {
|
||||
if (n == 0) {
|
||||
sg[n] = 0;
|
||||
} else if (n == 1) {
|
||||
sg[n] = 0;
|
||||
} else if (n == 2) {
|
||||
sg[n] = 1;
|
||||
} else if (n == 3) {
|
||||
sg[n] = 1;
|
||||
} else if (sg[n] == -1) {
|
||||
int i;
|
||||
memset(vis, false, sizeof(vis));
|
||||
for (i = 0; i <= n - 2; i++) {
|
||||
vis[SG(i) ^ SG(n - i - 2)] = true;
|
||||
}
|
||||
for (i = 0;; i++) {
|
||||
if (!vis[i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
sg[n] = i;
|
||||
}
|
||||
return sg[n];
|
||||
}
|
||||
void init() {
|
||||
int i;
|
||||
memset(sg, -1, sizeof(sg));
|
||||
for (i = 0; i < MAXN; i++) {
|
||||
sg[i] = SG(i);
|
||||
}
|
||||
}
|
||||
int getSG(int n) {
|
||||
if (n < MAXN) {
|
||||
return sg[n];
|
||||
} else {
|
||||
return sg[n % 34 + 2 * 34];
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int T;
|
||||
int n;
|
||||
int tmp;
|
||||
int res;
|
||||
init();
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d", &n);
|
||||
res = 0;
|
||||
while (n--) {
|
||||
scanf("%d", &tmp);
|
||||
res ^= getSG(tmp);
|
||||
}
|
||||
if (res) {
|
||||
puts("Carol");
|
||||
} else {
|
||||
puts("Dave");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#define MAXN 2010
|
||||
using namespace std;
|
||||
int arr[MAXN];
|
||||
char str[MAXN];
|
||||
bool flag;
|
||||
int idx[MAXN];
|
||||
int cnt[MAXN];
|
||||
int st[2][MAXN];
|
||||
int belong[MAXN];
|
||||
int n;
|
||||
vector<int> pos[MAXN];
|
||||
void dfs(int x, int p1, int p2) {
|
||||
if (x > n) {
|
||||
flag = true;
|
||||
}
|
||||
if (flag) {
|
||||
return;
|
||||
}
|
||||
if (p1 > 0 && p2 > 0
|
||||
&& arr[st[0][min(p1, p2)]] != arr[st[1][min(p1, p2)]]) {
|
||||
return;
|
||||
}
|
||||
if (belong[x] == 0) {
|
||||
st[0][p1 + 1] = x;
|
||||
dfs(x + 1, p1 + 1, p2);
|
||||
} else if (belong[x] == 1) {
|
||||
st[1][p2 + 1] = x;
|
||||
dfs(x + 1, p1, p2 + 1);
|
||||
} else {
|
||||
st[0][p1 + 1] = x;
|
||||
belong[pos[arr[x]][2]] = 1;
|
||||
dfs(x + 1, p1 + 1, p2);
|
||||
if (!flag) {
|
||||
st[1][p2 + 1] = x;
|
||||
belong[pos[arr[x]][2]] = 0;
|
||||
dfs(x + 1, p1, p2 + 1);
|
||||
belong[pos[arr[x]][2]] = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int T;
|
||||
int i;
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d", &n);
|
||||
memset(idx, 0, sizeof(idx));
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
for (i = 1; i <= n; i++) {
|
||||
scanf("%d", &arr[i]);
|
||||
cnt[arr[i]]++;
|
||||
idx[i] = cnt[arr[i]];
|
||||
pos[arr[i]].clear();
|
||||
}
|
||||
memset(belong, -1, sizeof(belong));
|
||||
for (i = 1; i <= n; i++) {
|
||||
if (idx[i] == 1) {
|
||||
belong[i] = 0;
|
||||
} else if (idx[i] == 2 && cnt[arr[i]] == 2) {
|
||||
belong[i] = 1;
|
||||
} else if (idx[i] == 4) {
|
||||
belong[i] = 1;
|
||||
}
|
||||
pos[arr[i]].push_back(i);
|
||||
}
|
||||
flag = false;
|
||||
dfs(1, 0, 0);
|
||||
for (i = 1; i <= (n >> 1); i++) {
|
||||
str[st[0][i]] = '0';
|
||||
str[st[1][i]] = '1';
|
||||
}
|
||||
for (i = 1; i <= n; i++) {
|
||||
putchar(str[i]);
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<set>
|
||||
using namespace std;
|
||||
#define maxn 60002
|
||||
int maps[maxn][6];
|
||||
multiset<int>se[1<<5];
|
||||
multiset<int>::iterator i1,i2;
|
||||
int main()
|
||||
{
|
||||
int i,j,leap,x,n,m,a;
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
for(i=0;i<(1<<5);i++)
|
||||
se[i].clear();
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&leap);
|
||||
if(leap==0)
|
||||
{
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&maps[i][j]);
|
||||
}
|
||||
for(a=0;a<(1<<m);a++)
|
||||
{
|
||||
int as;
|
||||
as=0;
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
if(a&(1<<j))as+=maps[i][j];
|
||||
else as-=maps[i][j];
|
||||
}
|
||||
se[a].insert(as);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d",&x);
|
||||
for(a=0;a<(1<<m);a++)
|
||||
{
|
||||
int as;
|
||||
as=0;
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
if(a&(1<<j))as+=maps[x][j];
|
||||
else as-=maps[x][j];
|
||||
}
|
||||
i1=se[a].find(as);
|
||||
se[a].erase(i1);
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for(a=0;a<(1<<m);a++)
|
||||
{
|
||||
i1=se[a].begin();
|
||||
i2=se[a].end();
|
||||
i2--;
|
||||
ans=max(ans,(*i2)-(*i1));
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#define PI 3.1415926
|
||||
using namespace std;
|
||||
struct list
|
||||
{
|
||||
double x;
|
||||
double y;
|
||||
int r;
|
||||
int pos;
|
||||
}point[500001],tu[500001],pp;
|
||||
int tops,num;
|
||||
int cmp1(struct list a,struct list b)
|
||||
{
|
||||
if(a.y!=b.y)return a.y<b.y;
|
||||
else return a.x<b.x;
|
||||
}
|
||||
int cmp2(struct list a,struct list b)
|
||||
{
|
||||
if((a.x-point[0].x)*(b.y-point[0].y)==(b.x-point[0].x)*(a.y-point[0].y))
|
||||
return ((a.x-point[0].x)*(a.x-point[0].x)+(a.y-point[0].y)*(a.y-point[0].y))<((point[0].x-b.x)*(point[0].x-b.x)+(point[0].y-b.y)*(point[0].y-b.y));
|
||||
return (a.x-point[0].x)*(b.y-point[0].y)>(b.x-point[0].x)*(a.y-point[0].y);
|
||||
}
|
||||
int ts;
|
||||
void yuan(int x,int y,int r)
|
||||
{
|
||||
pp.r=r;
|
||||
for(int i=0;i<500;i++)
|
||||
{
|
||||
double du;
|
||||
du=(double)2.0*PI*i/500.0;
|
||||
pp.x=1.0*x+1.0*r*cos(du);
|
||||
pp.y=1.0*y+1.0*r*sin(du);
|
||||
pp.pos=ts;
|
||||
point[tops++]=pp;
|
||||
}
|
||||
}
|
||||
int pan(int z,int b,int a)
|
||||
{
|
||||
double x1,y1,x2,y2;
|
||||
if(a<0)return 1;
|
||||
x1=tu[b].x-tu[a].x;
|
||||
y1=tu[b].y-tu[a].y;
|
||||
x2=point[z].x-tu[b].x;
|
||||
y2=point[z].y-tu[b].y;
|
||||
if(x1*y2>x2*y1)return 1;
|
||||
return 0;
|
||||
}
|
||||
double len(struct list p1,struct list p2)
|
||||
{
|
||||
return (double)sqrt(1.0*((p1.x-p2.x)*(p1.x-p2.x)+1.0*(p1.y-p2.y)*(p1.y-p2.y)));
|
||||
}
|
||||
void init(int n,int m)
|
||||
{
|
||||
int i,j;
|
||||
tops=0;
|
||||
int a,b,c;
|
||||
ts=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
ts++;
|
||||
yuan(a,b,c);
|
||||
}
|
||||
for(i=0;i<m;i++)
|
||||
for(j=0;j<3;j++)
|
||||
{
|
||||
scanf("%lf%lf",&point[tops].x,&point[tops].y);
|
||||
point[tops].pos=0;
|
||||
tops++;
|
||||
}
|
||||
}
|
||||
void jiantu()
|
||||
{
|
||||
int i;
|
||||
sort(point,point+tops,cmp1);
|
||||
sort(point+1,point+tops,cmp2);
|
||||
tu[0]=point[0];
|
||||
tu[1]=point[1];
|
||||
tu[2]=point[2];
|
||||
num=3;
|
||||
for(i=3;i<tops;i++)
|
||||
{
|
||||
while(!pan(i,num-1,num-2))num--;
|
||||
tu[num++]=point[i];
|
||||
}
|
||||
}
|
||||
void print()
|
||||
{
|
||||
double lens;
|
||||
int i;
|
||||
lens=0.0;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
if(tu[i].pos>0&&(tu[i].pos==tu[(i+1)%num].pos))
|
||||
{
|
||||
lens+=1.0*tu[i].r*2*PI/500.0;
|
||||
}
|
||||
else
|
||||
lens+=len(tu[i],tu[(i+1)%num]);
|
||||
}
|
||||
printf("%.5lf\n",lens);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
init(n,m);
|
||||
jiantu();
|
||||
print();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#define lson step << 1
|
||||
#define rson step << 1 | 1
|
||||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 5005;
|
||||
struct Node {
|
||||
string s;
|
||||
int cnt;
|
||||
Node () {}
|
||||
Node (string _s , int c) :s(_s) , cnt(c) {}
|
||||
string cat () {
|
||||
string t = s;
|
||||
for (int i = 1 ; i < cnt ; i ++)
|
||||
s = s + t;
|
||||
cnt = 1;
|
||||
return s;
|
||||
}
|
||||
LL len () {
|
||||
return (LL)s.size() * cnt;
|
||||
}
|
||||
string prefix (int l) {
|
||||
string str = s;
|
||||
for (int i = 1 ; i < cnt && str.size() < l ; i ++) {
|
||||
str += s;
|
||||
}
|
||||
return str.substr (0 , l);
|
||||
}
|
||||
string suffix (int l) {
|
||||
string str = s;
|
||||
for (int i = 1 ; i < cnt && str.size() < l ; i ++) {
|
||||
str += s;
|
||||
}
|
||||
return str.substr (str.size() - l , l);
|
||||
}
|
||||
}a[N];
|
||||
char str[N] , pat[N];
|
||||
int ne[N] , idx , l , p;
|
||||
void get_next (char *s , int l) {
|
||||
ne[0] = -1;
|
||||
int i = 0 , j = -1;
|
||||
while (i < l) {
|
||||
if (j == -1 || s[i] == s[j]) {
|
||||
i ++; j ++;
|
||||
ne[i] = j;
|
||||
}
|
||||
else j = ne[j];
|
||||
}
|
||||
}
|
||||
void gao (string s , int tot) {
|
||||
if (s == "") return ;
|
||||
if (idx == 0 || s.size() * tot >= p || a[idx - 1].len() >= p) {
|
||||
a[idx ++] = Node (s , tot);
|
||||
}
|
||||
else {
|
||||
a[idx - 1].cat ();
|
||||
a[idx - 1].s += Node (s , tot).cat();
|
||||
}
|
||||
}
|
||||
int match (string s , char *t , int p) {
|
||||
int l = s.size() ;
|
||||
int i = 0 , j = 0 , ans = 0;
|
||||
while (i < s.size()) {
|
||||
if (j == - 1 || s[i] == t[j]) {
|
||||
i ++; j ++;
|
||||
if (j == p) {
|
||||
ans ++;
|
||||
j = ne[j];
|
||||
}
|
||||
}
|
||||
else j = ne[j];
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main () {
|
||||
while (scanf ("%s %s" , str , pat) != EOF) {
|
||||
idx = 0;
|
||||
l = strlen (str);p = strlen (pat);
|
||||
get_next (pat , p);
|
||||
string s = "";
|
||||
int tot = 1;
|
||||
for (int i = 0 ; i < l ; i ++) {
|
||||
if (str[i] == '[') {
|
||||
if (s == "") continue;
|
||||
gao (s , tot);
|
||||
s = ""; tot = 1;
|
||||
}
|
||||
else if (str[i] == ']') {
|
||||
tot = 0;
|
||||
i ++;
|
||||
while (isdigit(str[i]))
|
||||
tot = tot * 10 + str[i ++] - '0';
|
||||
i --;
|
||||
gao (s , tot);
|
||||
s = ""; tot = 1;
|
||||
}
|
||||
else s += str[i];
|
||||
}
|
||||
gao (s , tot);
|
||||
s = ""; tot = 1;
|
||||
LL ans = 0;
|
||||
for (int i = 0 ; i < idx ; i ++) {
|
||||
if (a[i].len() < p) continue;
|
||||
if (a[i].cnt == 1) ans += match (a[i].s , pat , p);
|
||||
else {
|
||||
int use = min(a[i].cnt , 1 + (p - 1 + (int)a[i].s.size() - 1) / (int)a[i].s.size());
|
||||
string s = "";
|
||||
for (int j = 1 ; j < use ; j ++) {
|
||||
s += a[i].s;
|
||||
}
|
||||
s = a[i].s + s.substr (0 , min ((int)s.size() , p - 1));
|
||||
int tmp = match (s , pat , p);
|
||||
ans += (LL)tmp * (a[i].cnt - use + 1);
|
||||
if (p) {
|
||||
s = "";
|
||||
for (int j = 1 ; j < use ; j ++)
|
||||
s += a[i].s;
|
||||
ans += match (s , pat , p);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 0 ; i < idx - 1 ; i ++) {
|
||||
s = a[i].suffix (min (a[i].len () , p - 1LL));
|
||||
if (a[i + 1].len () < p - 1) {
|
||||
s += a[i + 1].cat ();
|
||||
if (i + 2 < idx) {
|
||||
s += a[i + 2].prefix (min (a[i + 2].len () , p - 1 - a[i + 2].len ()));
|
||||
}
|
||||
}
|
||||
else {
|
||||
s += a[i + 1].prefix (min (a[i + 1].len () , p - 1LL));
|
||||
}
|
||||
ans += match (s , pat , p);
|
||||
}
|
||||
printf ("%I64d\n" , ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#define lson step << 1
|
||||
#define rson step << 1 | 1
|
||||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 50005;
|
||||
const int M = 205;
|
||||
int n , k , a[N] ,l[N];
|
||||
int dp[2][M] , prefix[N] , fac[N << 2] , suffix[N];
|
||||
int cnt[M];
|
||||
int cal (int x) {
|
||||
int cnt = 0;
|
||||
while (x) x /= 10 , cnt ++;
|
||||
return cnt;
|
||||
}
|
||||
int main () {
|
||||
while (scanf ("%d %d" , &n , &k) != EOF) {
|
||||
fac[0] = 1;
|
||||
for (int i = 1 ; i <= (n << 2) ; i ++)
|
||||
fac[i] = fac[i - 1] * 10 % k;
|
||||
for (int i = 1 ; i <= n ; i ++) {
|
||||
scanf ("%d" , &a[i]);
|
||||
l[i] = cal (a[i]);
|
||||
}
|
||||
for (int i = 0 ; i < 2 ; i ++) {
|
||||
for (int j = 0 ; j < k ; j ++)
|
||||
dp[i][j] = 0;
|
||||
}
|
||||
dp[1][a[1] % k] = 1;
|
||||
LL ans = dp[1][0];
|
||||
for (int i = 2 ; i <= n ; i ++) {
|
||||
for (int j = 0 ; j < k ; j ++)
|
||||
dp[i & 1][j] = 0;
|
||||
dp[i & 1][a[i] % k] ++;
|
||||
for (int j = 0 ; j < k ; j ++) {
|
||||
dp[i & 1][(j * fac[l[i]] + a[i]) %k] += dp[(i - 1) & 1][j];
|
||||
}
|
||||
ans += dp[i & 1][0];
|
||||
}
|
||||
prefix[0] = 0;suffix[n + 1] = 0;
|
||||
for (int i = 1 ; i <= n ; i ++) {
|
||||
prefix[i] = (prefix[i - 1] * fac[l[i]] + a[i]) % k;
|
||||
}
|
||||
int len = 0;
|
||||
for (int i = n ; i >= 1 ; i --) {
|
||||
suffix[i] = (a[i] * fac[len] + suffix[i + 1]) % k;
|
||||
len += l[i];
|
||||
}
|
||||
len = 0;
|
||||
for (int i = 0 ; i < k ; i ++)
|
||||
cnt[i] = 0;
|
||||
for (int i = 1 ; i <= n ; i ++) {
|
||||
cnt[suffix[i]] ++;
|
||||
len += l[i];
|
||||
int p = prefix[i];
|
||||
for (int j = 0 ; j < k ; j ++) {
|
||||
if ((j * fac[len] + p) % k) continue;
|
||||
ans += dp[n & 1][j] - cnt[j];
|
||||
}
|
||||
}
|
||||
printf ("%I64d\n" , ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,171 @@
|
|||
#pragma comment(linker,"/STACK:102400000,102400000")
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
#define rep(i,s,t) for(int i=s;i<t;i++)
|
||||
#define red(i,s,t) for(int i=s-1;i>=t;i--)
|
||||
#define ree(i,now) for(int i=head[now];i!=-1;i=edge[i].next)
|
||||
#define clr(a,v) memset(a,v,sizeof a)
|
||||
const int N=50005;
|
||||
const int K=33;
|
||||
struct Edge{
|
||||
int v,next;
|
||||
}edge[N*2];
|
||||
int head[N],e;
|
||||
int Num[N][K];
|
||||
int son[N],MaxSize;
|
||||
int root,all;
|
||||
int n,k,a[K],d[K],x,y,cnt;
|
||||
ll v[N],dis[N],three[K],mark[N];
|
||||
int Ans;
|
||||
bool vis[N];
|
||||
map<ll,int>mp,mpp;
|
||||
inline void Init(){
|
||||
three[0]=1;
|
||||
rep(i,1,K) three[i]=three[i-1]*3;
|
||||
}
|
||||
inline int getPos(ll v,int x){
|
||||
return v%three[x+1]/three[x];
|
||||
}
|
||||
inline ll get(ll val,int *x){
|
||||
ll ans=0;
|
||||
rep(i,0,k) ans+=((getPos(val,i)+x[i])%3)*three[i];
|
||||
return ans;
|
||||
}
|
||||
inline void getCh(ll b,int i){
|
||||
bool ok=1;
|
||||
mark[i]=0;
|
||||
if(b==0)return;
|
||||
rep(j,0,k){
|
||||
Num[i][j]=0;
|
||||
while(b>1 && b%a[j]==0){
|
||||
Num[i][j]++;
|
||||
b/=a[j];
|
||||
}
|
||||
Num[i][j]%=3;
|
||||
mark[i]+=three[j]*Num[i][j];
|
||||
if(Num[i][j]!=0) ok=0;
|
||||
}
|
||||
if(ok) Ans++;
|
||||
}
|
||||
inline void addEdge(int u,int v){
|
||||
edge[e].v=v;
|
||||
edge[e].next=head[u];
|
||||
head[u]=e++;
|
||||
}
|
||||
inline void In(){
|
||||
scanf("%d",&k);
|
||||
rep(i,0,k) scanf("%d",&a[i]);
|
||||
rep(i,1,n+1){
|
||||
scanf("%I64d",&v[i]);
|
||||
getCh(v[i],i);
|
||||
}
|
||||
clr(head,-1),e=0;
|
||||
rep(i,1,n){
|
||||
scanf("%d%d",&x,&y);
|
||||
addEdge(x,y);addEdge(y,x);
|
||||
}
|
||||
clr(vis,0);
|
||||
}
|
||||
inline void dfs_Size(int now,int pre){
|
||||
all++;
|
||||
ree(i,now){
|
||||
int nxt=edge[i].v;
|
||||
if(!vis[nxt] && nxt!=pre) dfs_Size(nxt,now);
|
||||
}
|
||||
}
|
||||
inline void dfs_Root(int now,int pre){
|
||||
int Max=0;
|
||||
son[now]=0;
|
||||
ree(i,now){
|
||||
int nxt=edge[i].v;
|
||||
if(!vis[nxt] && pre!=nxt){
|
||||
dfs_Root(nxt,now);
|
||||
son[now]+=son[nxt]+1;
|
||||
if(son[nxt]+1>Max) Max=son[nxt]+1;
|
||||
}
|
||||
}
|
||||
int res=all-son[now]-1;
|
||||
if(Max<res) Max=res;
|
||||
if(Max<MaxSize){
|
||||
MaxSize=Max;root=now;
|
||||
}
|
||||
}
|
||||
inline ll Val(int *c){
|
||||
ll ans=0;
|
||||
rep(j,0,k) ans+=c[j]*three[j];
|
||||
return ans;
|
||||
}
|
||||
inline ll Transform(ll a,ll b){
|
||||
ll ans=0;
|
||||
rep(j,0,k) ans+=(getPos(a,j)+getPos(b,j))%3*three[j];
|
||||
return ans;
|
||||
}
|
||||
inline void dfs_Dis(int now,int pre,ll val){
|
||||
dis[cnt++]=val;
|
||||
ree(i,now){
|
||||
int nxt=edge[i].v;
|
||||
if(!vis[nxt] && nxt!=pre){
|
||||
dfs_Dis(nxt,now,Transform(val,mark[nxt]));
|
||||
}
|
||||
}
|
||||
}
|
||||
inline ll Suit(ll v){
|
||||
ll ans=0;
|
||||
rep(i,0,k){
|
||||
int x=getPos(v,i);
|
||||
int y=(3-x)%3;
|
||||
ans+=three[i]*y;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
inline void Work(int now){
|
||||
all=0;
|
||||
dfs_Size(now,-1);
|
||||
MaxSize=n+10;
|
||||
dfs_Root(now,-1);
|
||||
vis[root]=1;
|
||||
mp.clear();
|
||||
ree(i,root){
|
||||
int nxt=edge[i].v;cnt=0;
|
||||
if(vis[nxt]) continue;
|
||||
dfs_Dis(nxt,root,mark[nxt]);
|
||||
rep(j,0,cnt){
|
||||
int vv=mp[Suit(dis[j])];
|
||||
if(vv) Ans+=vv;
|
||||
}
|
||||
rep(j,0,cnt){
|
||||
ll p=get(dis[j],Num[root]);
|
||||
if(p==0) Ans++;
|
||||
mp[p]++;
|
||||
}
|
||||
}
|
||||
ree(i,root){
|
||||
int nxt=edge[i].v;
|
||||
if(!vis[nxt]){
|
||||
Work(nxt);
|
||||
}
|
||||
}
|
||||
}
|
||||
inline void app(){
|
||||
int a[]={2,3,5,7,11,13,17,19,23,29};
|
||||
rep(j,0,10){
|
||||
printf("3000 10 2 3 5 7 11 13 17 19 23 29\n");
|
||||
rep(i,0,3000) printf("%d ",a[rand()%10]);
|
||||
rep(i,1,3000) printf("%d 1\n",i+1);
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
Init();
|
||||
while(~scanf("%d",&n)){
|
||||
Ans=0;
|
||||
In();
|
||||
Work(1);
|
||||
printf("%d\n",Ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int V = 105;
|
||||
int n, m, ans[V][V];
|
||||
bool vis[V][V];
|
||||
int main() {
|
||||
int i, j, k;
|
||||
while(~scanf("%d%d", &n, &m)) {
|
||||
memset(ans, 0, sizeof(ans));
|
||||
memset(vis, false, sizeof(vis));
|
||||
for(i = 0, j = 1; i < m; ++i) {
|
||||
ans[i][0] = j;
|
||||
vis[i][j] = true;
|
||||
j = j == n ? 1 : j + 1;
|
||||
}
|
||||
for(i = 0; i < m; ++i) {
|
||||
if(ans[i][1] != 0)
|
||||
continue;
|
||||
int now = m % n + 1;
|
||||
for(j = i; j < m; j += n) {
|
||||
if(now == ans[j][0])
|
||||
now = now == n ? 1 : now + 1;
|
||||
ans[j][1] = now;
|
||||
vis[j][now] = true;
|
||||
now = now == n ? 1 : now + 1;
|
||||
}
|
||||
}
|
||||
for(i = 0; i < m; ++i)
|
||||
for(j = 2, k = 1; j < n; ++j) {
|
||||
while(vis[i][k])
|
||||
k++;
|
||||
ans[i][j] = k++;
|
||||
}
|
||||
for(i = 0; i < m; ++i) {
|
||||
for(j = 0; j < n - 1; ++j)
|
||||
printf("%d ", ans[i][j]);
|
||||
printf("%d\n", ans[i][n - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#define I(x) scanf("%d",&x)
|
||||
using namespace std;
|
||||
int sg[10001],a[100001];
|
||||
char x[20],y[20];
|
||||
int main(){
|
||||
int n,m,i,j,MIN,b,t,ans;
|
||||
while(scanf("%d%d%s%s",&n,&m,x,y)!=EOF){
|
||||
memset(sg,-1,sizeof(sg));
|
||||
sg[0]=0;MIN=1e9;
|
||||
bool flag=0;
|
||||
for(i=0;i<n;i++) I(a[i]);
|
||||
for(i=0;i<m;i++){
|
||||
I(b);
|
||||
MIN=min(MIN,b);
|
||||
for(j=0;j+b<=10000;j++)
|
||||
if(sg[j]>=0)
|
||||
sg[j+b]=max(sg[b+j],sg[j]+1);
|
||||
}
|
||||
ans=0;
|
||||
for(i=0;i<n;i++){
|
||||
t=a[i];
|
||||
if(t<=10000){
|
||||
if(sg[t]<0) flag=1;
|
||||
else ans^=sg[t];
|
||||
}
|
||||
else{
|
||||
t=(t-10000+MIN)%MIN+10000-MIN;
|
||||
if(sg[t]<0) flag=1;
|
||||
else ans^=sg[t]+(a[i]-t)/MIN;
|
||||
}
|
||||
}
|
||||
if(!flag&&ans) puts(x);
|
||||
else puts(y);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
#pragma comment(linker, "/STACK:65536000")
|
||||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <math.h>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#define clr(a,b) memset(a,b,sizeof(a))
|
||||
#define mpr(a,b) make_pair(a,b)
|
||||
#define ll long long
|
||||
#define eps 1e-6
|
||||
using namespace std;
|
||||
const int N=100005,M=300005;
|
||||
int n,m,q,eid,id,now,top;
|
||||
int head[N],ed[M],nxt[M];
|
||||
int dfn[N],low[N],gid[N];
|
||||
int sta[N],block[N];
|
||||
vector<pair<int,int> >gra[N],qu[N];
|
||||
int f[N],vis[N],come[N],out[N],fa[N];
|
||||
int tlca[3*N],pt[3*N][2];
|
||||
int aa[N],bb[N],cc[N];
|
||||
int findfa(int s){return s==fa[s]?s:fa[s]=findfa(fa[s]);}
|
||||
void addedge(int s,int e){
|
||||
ed[eid]=e;nxt[eid]=head[s];head[s]=eid++;
|
||||
}
|
||||
void tarjan(int s,int f,int b){
|
||||
dfn[s]=low[s]=++now;
|
||||
sta[top++]=s;block[s]=b;
|
||||
for(int i=head[s];~i;i=nxt[i]){
|
||||
int e=ed[i];
|
||||
if(i==f||i==(f^1))continue;
|
||||
if(!dfn[e]){
|
||||
tarjan(e,i,b);
|
||||
low[s]=min(low[s],low[e]);
|
||||
}else
|
||||
low[s]=min(low[s],dfn[e]);
|
||||
}
|
||||
if(low[s]==dfn[s]){
|
||||
id++;
|
||||
while(top){
|
||||
int k=sta[--top];
|
||||
gid[k]=id;
|
||||
if(k==s)return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
void lca(int s,int f){
|
||||
fa[s]=s;
|
||||
for(int i=0;i<(int)gra[s].size();i++){
|
||||
int e=gra[s][i].first;
|
||||
if(e==f)continue;
|
||||
lca(e,s);
|
||||
fa[findfa(e)]=s;
|
||||
}
|
||||
vis[s]=1;
|
||||
for(int i=0;i<(int)qu[s].size();i++){
|
||||
int e=qu[s][i].first,d=qu[s][i].second;
|
||||
if(vis[e])tlca[d]=findfa(e);
|
||||
}
|
||||
}
|
||||
void dfs(int s,int f){
|
||||
for(int i=0;i<(int)qu[s].size();i++){
|
||||
int d=qu[s][i].second;
|
||||
int k=(tlca[d]==s)?-1:out[tlca[d]];
|
||||
if(~pt[d][0])pt[d][1]=k;
|
||||
else pt[d][0]=k;
|
||||
}
|
||||
for(int i=0;i<(int)gra[s].size();i++){
|
||||
int e=gra[s][i].first,g=gra[s][i].second;
|
||||
if(e==f){
|
||||
come[s]=g;continue;
|
||||
}
|
||||
out[s]=g;
|
||||
dfs(e,s);
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%d%d",&n,&m)){
|
||||
eid=0;clr(head,-1);
|
||||
for(int i=0;i<m;i++){
|
||||
int a,b;scanf("%d%d",&a,&b);
|
||||
addedge(a,b);addedge(b,a);
|
||||
}
|
||||
id=now=top=0;
|
||||
for(int i=1;i<=n;i++)dfn[i]=0;
|
||||
int cnt=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
if(!dfn[i])tarjan(i,-1,++cnt);
|
||||
for(int i=1;i<=id;i++){
|
||||
gra[i].clear();qu[i].clear();
|
||||
}
|
||||
for(int i=1;i<=n;i++)
|
||||
for(int j=head[i];~j;j=nxt[j]){
|
||||
int s=gid[i],e=gid[ed[j]];
|
||||
if(s!=e)gra[s].push_back(mpr(e,i));
|
||||
}
|
||||
clr(f,0);
|
||||
scanf("%d",&q);
|
||||
for(int i=0;i<q;i++){
|
||||
int a,b,c;scanf("%d%d%d",&a,&b,&c);
|
||||
if(block[a]!=block[b]){f[i]=1;continue;}
|
||||
if(block[b]!=block[c]){f[i]=1;continue;}
|
||||
if(block[a]!=block[c]){f[i]=1;continue;}
|
||||
if(a==b&&a!=c){f[i]=1;continue;}
|
||||
int s=gid[a],e=gid[b],k=gid[c];
|
||||
qu[s].push_back(mpr(e,i*3));
|
||||
qu[e].push_back(mpr(s,i*3));
|
||||
qu[s].push_back(mpr(k,i*3+1));
|
||||
qu[k].push_back(mpr(s,i*3+1));
|
||||
qu[e].push_back(mpr(k,i*3+2));
|
||||
qu[k].push_back(mpr(e,i*3+2));
|
||||
aa[i]=a;bb[i]=b;cc[i]=c;
|
||||
}
|
||||
for(int i=1;i<=id;i++)vis[i]=0;
|
||||
for(int i=0;i<q*3;i++)
|
||||
pt[i][0]=pt[i][1]=-1;
|
||||
for(int i=1;i<=id;i++)
|
||||
if(!vis[i]){
|
||||
lca(i,-1);
|
||||
dfs(i,-1);
|
||||
}
|
||||
for(int i=0;i<q;i++){
|
||||
if(f[i]){
|
||||
puts("No");continue;
|
||||
}
|
||||
if(gid[aa[i]]==gid[bb[i]]){
|
||||
if(gid[cc[i]]==gid[aa[i]])puts("Yes");
|
||||
else puts("No");
|
||||
}
|
||||
else if(gid[cc[i]]==tlca[i*3]){
|
||||
if(pt[i*3][1]==-1){
|
||||
int k=(gid[aa[i]]==gid[cc[i]])?aa[i]:bb[i];
|
||||
if(k==pt[i*3][0]&&cc[i]!=k) puts("No");
|
||||
else puts("Yes");
|
||||
}else{
|
||||
if(pt[i*3][0]==pt[i*3][1]&&cc[i]!=pt[i*3][0]) puts("No");
|
||||
else puts("Yes");
|
||||
}
|
||||
}else if(tlca[i*3+1]==gid[cc[i]]&&tlca[i*3+2]==tlca[i*3]){
|
||||
int k=(pt[i*3+1][0]==-1)?aa[i]:pt[i*3+1][0];
|
||||
if(come[gid[cc[i]]]==k&&k!=cc[i])puts("No");
|
||||
else puts("Yes");
|
||||
}else if(tlca[i*3+2]==gid[cc[i]]&&tlca[i*3+1]==tlca[i*3]){
|
||||
int k=(pt[i*3+2][0]==-1)?bb[i]:pt[i*3+2][0];
|
||||
if(come[gid[cc[i]]]==k&&k!=cc[i])puts("No");
|
||||
else puts("Yes");
|
||||
}else puts("No");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#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>
|
||||
using namespace std;
|
||||
const int MOD = 1e9+7;
|
||||
long long pow_m(long long a,long long n)
|
||||
{
|
||||
long long ret = 1;
|
||||
long long tmp = a%MOD;
|
||||
while(n)
|
||||
{
|
||||
if(n&1)
|
||||
{
|
||||
ret *= tmp;
|
||||
ret %= MOD;
|
||||
}
|
||||
tmp *= tmp;
|
||||
tmp %= MOD;
|
||||
n >>= 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
long long C[300010];
|
||||
long long inv(long long a,long long m)
|
||||
{
|
||||
if(a == 1)return 1;
|
||||
return inv(m%a,m)*(m-m/a)%m;
|
||||
}
|
||||
long long ans[300010];
|
||||
int a[300010];
|
||||
int num[300010];
|
||||
int b[300010];
|
||||
int main()
|
||||
{
|
||||
int N,M,K;
|
||||
while(scanf("%d%d%d",&N,&M,&K) == 3)
|
||||
{
|
||||
memset(num,0,sizeof(num));
|
||||
for(int i = 1;i <= N;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
num[a[i]]++;
|
||||
}
|
||||
C[N-K] = 1;
|
||||
for(int i = N-K+1;i <= N;i++)
|
||||
{
|
||||
C[i] = C[i-1]*i%MOD*inv(i-(N-K),MOD)%MOD;
|
||||
}
|
||||
for(int i = M;i>= 1;i--)
|
||||
{
|
||||
int cnt = 0;
|
||||
long long ss = 0;
|
||||
for(int j = 1; j*i <= M;j++)
|
||||
{
|
||||
cnt += num[i*j];
|
||||
if(j > 1)ss = (ss + ans[i*j])%MOD;
|
||||
}
|
||||
int t = M/i;
|
||||
if(t == 1)
|
||||
{
|
||||
if(cnt == N-K)ans[i] = 1;
|
||||
else ans[i] = 0;
|
||||
continue;
|
||||
}
|
||||
if(cnt < N-K)
|
||||
{
|
||||
ans[i] = 0;
|
||||
continue;
|
||||
}
|
||||
long long tmp = 1;
|
||||
tmp =(tmp*C[cnt])%MOD;
|
||||
tmp = ( tmp * pow_m(t-1,cnt-(N-K)) )%MOD;
|
||||
tmp = (tmp * pow_m(t,N-cnt));
|
||||
ans[i] = (tmp - ss + MOD)%MOD;
|
||||
}
|
||||
for(int i = 1;i <= M;i++)
|
||||
{
|
||||
printf("%I64d",ans[i]);
|
||||
if(i < M)printf(" ");
|
||||
else printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<climits>
|
||||
#include<string>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<stdlib.h>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int MAXN = 20007;
|
||||
vector<int> divisor[MAXN];
|
||||
int f[MAXN], a[MAXN], L[MAXN], R[MAXN], cnt[MAXN], qid[MAXN], M;
|
||||
ll ans[MAXN];
|
||||
void getdivisor() {
|
||||
int i, j;
|
||||
for(i = 1; i < MAXN; i++) for(j = i; j < MAXN; j += i) divisor[j].push_back(i);
|
||||
}
|
||||
void getf() {
|
||||
for(int i = 1; i < MAXN; i++) {
|
||||
int t = i;
|
||||
int j, sz = divisor[i].size();
|
||||
for(j = 0; j < sz; j++) t -= f[divisor[i][j]];
|
||||
f[i] = t;
|
||||
}
|
||||
}
|
||||
int qcmp(int x, int y) {
|
||||
int px = L[x] / M;
|
||||
int py = L[y] / M;
|
||||
if(px != py) return px < py;
|
||||
return R[x] < R[y];
|
||||
}
|
||||
ll erase(int x) {
|
||||
int i, y, sz = divisor[x].size();
|
||||
ll ret = 0;
|
||||
for(i = 0; i < sz; i++) {
|
||||
y = divisor[x][i];
|
||||
ret += 1LL*f[y]*(--cnt[y]);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
ll insert(int x) {
|
||||
int i, y, sz = divisor[x].size();
|
||||
ll ret = 0;
|
||||
for(i = 0; i < sz; i++) {
|
||||
y = divisor[x][i];
|
||||
ret += 1LL*f[y]*(cnt[y]++);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void solve(int n, int q) {
|
||||
int i;
|
||||
for(i = 1; i <= q; i++) qid[i] = i;
|
||||
M = (int)sqrt(n*1.0);
|
||||
sort(qid+1, qid+1+q, qcmp);
|
||||
memset(cnt, 0, sizeof(cnt));
|
||||
int l = 0, r = 0;
|
||||
ll now = 0;
|
||||
for(i = 1; i <= q; i++) {
|
||||
int id = qid[i];
|
||||
int nl = L[id], nr = R[id];
|
||||
while(l < nl) {
|
||||
now -= erase(a[l]);
|
||||
l++;
|
||||
}
|
||||
while(l > nl) {
|
||||
l--;
|
||||
now += insert(a[l]);
|
||||
}
|
||||
while(r < nr) {
|
||||
r++;
|
||||
now += insert(a[r]);
|
||||
}
|
||||
while(r > nr) {
|
||||
now -= erase(a[r]);
|
||||
r--;
|
||||
}
|
||||
ans[id] = now;
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
getdivisor();
|
||||
getf();
|
||||
int T, id = 0;
|
||||
scanf("%d", &T);
|
||||
while(T--) {
|
||||
int i, n, q;
|
||||
scanf("%d", &n);
|
||||
for(i = 1; i <= n; i++) scanf("%d", a+i);
|
||||
scanf("%d", &q);
|
||||
for(i = 1; i <= q; i++) scanf("%d%d", L+i, R+i);
|
||||
solve(n, q);
|
||||
printf("Case #%d:\n", ++id);
|
||||
for(i = 1; i <= q; i++) printf("%I64d\n", ans[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define N 30050
|
||||
struct Q
|
||||
{
|
||||
int r,idx;
|
||||
Q(int _r=0,int _idx=0):r(_r),idx(_idx){}
|
||||
};
|
||||
vector<Q>que[N];
|
||||
vector<int>edge[N];
|
||||
int fa[N][200],scc[200],rr[200];
|
||||
int ta[N],first[N],ans[N];
|
||||
int n,m,tot,every;
|
||||
int find(int i,int pos)
|
||||
{
|
||||
return fa[i][pos]==i?i:fa[i][pos]=find(fa[i][pos],pos);
|
||||
}
|
||||
void init()
|
||||
{
|
||||
for(int i=0;i<=n;++i)
|
||||
edge[i].clear(),que[i].clear();
|
||||
memset(scc,0,sizeof(scc));
|
||||
every=tot=sqrt(n*1.0);
|
||||
if(n*n!=tot) tot++;
|
||||
for(int i=0;;++i)
|
||||
{
|
||||
rr[i]=i*every;
|
||||
if(i*every>=n) break;
|
||||
}
|
||||
for(int i=0;i<=tot;++i)
|
||||
for(int j=0;j<=n;++j)
|
||||
fa[j][i]=j;
|
||||
memset(first,-1,sizeof(first));
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
int T;scanf("%d",&T);
|
||||
for(int kk=1;kk<=T;++kk)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
init();
|
||||
for(int i=1,u,v;i<=m;++i)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
if(u==v) continue;
|
||||
edge[u].push_back(v);
|
||||
edge[v].push_back(u);
|
||||
}
|
||||
int q;scanf("%d",&q);
|
||||
for(int i=1,u,v;i<=q;++i)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
que[u].push_back(Q(v,i));
|
||||
}
|
||||
int run_clock=0;
|
||||
for(int u=n;u>=1;--u)
|
||||
{
|
||||
for(int j=1;j<=tot;++j)
|
||||
{
|
||||
if(u>rr[j]) continue;
|
||||
scc[j]++;
|
||||
int inc=0;
|
||||
for(int i=0;i<edge[u].size();++i)
|
||||
{
|
||||
int v=edge[u][i];
|
||||
if(u<v&&v<=rr[j])
|
||||
{
|
||||
int u1=find(u,j);
|
||||
int v1=find(v,j);
|
||||
if(u1!=v1)
|
||||
{
|
||||
inc++;
|
||||
fa[v1][j]=u1;
|
||||
}
|
||||
}
|
||||
}
|
||||
scc[j]-=inc;
|
||||
}
|
||||
for(int z=0;z<que[u].size();++z)
|
||||
{
|
||||
run_clock++;
|
||||
int right=que[u][z].r;
|
||||
int pos;int inc=0;
|
||||
for(pos=0;pos<tot;++pos)
|
||||
if(rr[pos]<right&&right<=rr[pos+1]) break;
|
||||
for(int i=max(u+1,rr[pos]+1);i<=right;++i)
|
||||
{
|
||||
if(first[i]!=run_clock)
|
||||
{
|
||||
first[i]=run_clock;
|
||||
fa[i][tot+1]=i;
|
||||
}
|
||||
for(int j=0;j<edge[i].size();++j)
|
||||
if(u<=edge[i][j]&&edge[i][j]<i)
|
||||
{
|
||||
int v1=find(edge[i][j],pos);
|
||||
if(first[v1]!=run_clock)
|
||||
{
|
||||
first[v1]=run_clock;
|
||||
fa[v1][tot+1]=v1;
|
||||
}
|
||||
if(find(i,tot+1)!=find(v1,tot+1))
|
||||
{
|
||||
fa[find(v1,tot+1)][tot+1]=find(i,tot+1);
|
||||
inc++;
|
||||
}
|
||||
}
|
||||
}
|
||||
ans[que[u][z].idx]=scc[pos]+right-max(rr[pos],u-1)-inc;
|
||||
}
|
||||
}
|
||||
printf("Case #%d:\n",kk);
|
||||
for(int i=1;i<=q;++i)
|
||||
printf("%d\n",ans[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#define loop(s,i,n) for(i = s;i < n;i++)
|
||||
#define cl(a,b) memset(a,b,sizeof(a))
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
using namespace std;
|
||||
int map[1005][1005];
|
||||
int vis[1005][1005];
|
||||
int n,m,k;
|
||||
int num,odd,uod;
|
||||
int to[8][2] = {{0,1},{0,-1},{1,0},{1,-1},{1,1},{-1,-1},{-1,0,},{-1,1}};
|
||||
int judge(int a,int b)
|
||||
{
|
||||
if(a >= 0 && a < n && b>= 0 &&b < m)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
void paint(int x,int y)
|
||||
{
|
||||
int i,j;
|
||||
for(i = 0;i < 8;i++)
|
||||
{
|
||||
int a,b;
|
||||
a = x+to[i][0];
|
||||
b = y+to[i][1];
|
||||
if(judge(a,b) && !vis[a][b])
|
||||
map[a][b]++;
|
||||
}
|
||||
}
|
||||
void dfs(int x,int y)
|
||||
{
|
||||
if(map[x][y] == -1 || vis[x][y])
|
||||
return;
|
||||
vis[x][y] = 1;
|
||||
int i;
|
||||
for(i = 0;i < 8;i++)
|
||||
{
|
||||
int a,b;
|
||||
a = x+to[i][0];
|
||||
b = y+to[i][1];
|
||||
if(judge(a,b)&&vis[a][b] == 0)
|
||||
{
|
||||
if(map[a][b] > 0)
|
||||
num++,vis[a][b] = 1;
|
||||
else if(map[a][b] == 0)
|
||||
dfs(a,b);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,j,x,y;
|
||||
scanf("%d",&t);
|
||||
int icase = 0;
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d %d %d",&n,&m,&k);
|
||||
loop(0,i,n)
|
||||
{
|
||||
loop(0,j,m)
|
||||
map[i][j] = vis[i][j] = 0;
|
||||
}
|
||||
while(k--)
|
||||
{
|
||||
scanf("%d %d",&x,&y);
|
||||
map[x][y] = -1;
|
||||
vis[x][y] = 1;
|
||||
paint(x,y);
|
||||
}
|
||||
odd = uod = 0;
|
||||
loop(0,i,n)
|
||||
{
|
||||
loop(0,j,m)
|
||||
{
|
||||
num = 0;
|
||||
if(map[i][j] == 0 && !vis[i][j])
|
||||
{
|
||||
dfs(i,j);
|
||||
if(num%2)
|
||||
odd++;
|
||||
else
|
||||
uod++;
|
||||
}
|
||||
}
|
||||
}
|
||||
loop(0,i,n)
|
||||
{
|
||||
loop(0,j,m)
|
||||
{
|
||||
if(!vis[i][j] && map[i][j] > 0)
|
||||
uod++;
|
||||
}
|
||||
}
|
||||
printf("Case #%d: ",++icase);
|
||||
if(uod%2 || odd%2)
|
||||
puts("Xiemao");
|
||||
else
|
||||
puts("Fanglaoshi");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,177 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define maxn 100011
|
||||
#pragma comment(linker, "/STACK:1024000000,1024000000")
|
||||
#define INF 99999999
|
||||
struct list
|
||||
{
|
||||
int u,v,w,number;
|
||||
int next;
|
||||
} node[maxn*4];
|
||||
struct list2
|
||||
{
|
||||
int point;
|
||||
int len;
|
||||
}no[4][maxn],pp;
|
||||
int head[maxn*10];
|
||||
int low[maxn*2];
|
||||
int f[maxn];
|
||||
int ipf[maxn][2];
|
||||
int ips[maxn][2];
|
||||
int h[maxn];
|
||||
int tops,maxx,ipos,n;
|
||||
void add(int u,int v,int w,int number)
|
||||
{
|
||||
node[tops].u=u;
|
||||
node[tops].v=v;
|
||||
node[tops].w=w;
|
||||
node[tops].number=number;
|
||||
node[tops].next=head[u];
|
||||
head[u]=tops++;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(f,0,sizeof(f));
|
||||
memset(h,0,sizeof(h));
|
||||
memset(ipf,0,sizeof(ipf));
|
||||
memset(low,0,sizeof(low));
|
||||
memset(ips,0,sizeof(ips));
|
||||
tops=0;
|
||||
maxx=INF;
|
||||
ipos=maxn+10;
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<=n;i++)
|
||||
{
|
||||
no[1][i].len=no[2][i].len=no[3][i].len=0;
|
||||
no[1][i].point=no[2][i].point=no[3][i].point=0;
|
||||
}
|
||||
int a,b,c;
|
||||
for(int i=1; i<n; i++)
|
||||
{
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
add(a,b,c,i);
|
||||
add(b,a,c,i);
|
||||
}
|
||||
}
|
||||
int dfs(int x,int pre)
|
||||
{
|
||||
int ts,tt;
|
||||
ts=0;
|
||||
f[x]=0;
|
||||
for(int i=head[x]; i!=-1; i=node[i].next)
|
||||
{
|
||||
int y=node[i].v;
|
||||
if(y==pre)continue;
|
||||
tt=dfs(y,x)+1;
|
||||
ts=max(tt,ts);
|
||||
if(f[y]>=ipf[x][0])
|
||||
{
|
||||
ipf[x][1]=ipf[x][0];
|
||||
ipf[x][0]=f[y];
|
||||
ips[x][1]=ips[x][0]=y;
|
||||
}
|
||||
else if(f[y]>=ipf[x][1])
|
||||
{
|
||||
ipf[x][1]=f[y];
|
||||
}
|
||||
f[x]=max(f[x],f[y]);
|
||||
pp.point=y;
|
||||
pp.len=tt;
|
||||
for(int j=1; j<=3; j++)
|
||||
if(no[j][x].len<=tt)
|
||||
{
|
||||
for(int k=3; k>=j+1; k--)
|
||||
{
|
||||
no[k][x]=no[k-1][x];
|
||||
}
|
||||
no[j][x]=pp;
|
||||
break;
|
||||
}
|
||||
}
|
||||
int ds=no[1][x].len+no[2][x].len;
|
||||
f[x]=max(f[x],ds);
|
||||
return ts;
|
||||
}
|
||||
int chu(int pre,int x,int y)
|
||||
{
|
||||
int s1,s2,s3,s4;
|
||||
int leap=0;
|
||||
s1=s2=s3=s4=0;
|
||||
if(ips[x][0]!=y)s1=ipf[x][0];
|
||||
else s1=ipf[x][1];
|
||||
if(no[1][x].point!=y)s2=no[1][x].len,leap++;
|
||||
if(no[2][x].point!=y)s2+=no[2][x].len,leap++;
|
||||
if(no[3][x].point!=y&&leap==1)s2+=no[3][x].len,leap++;
|
||||
s3=h[x];
|
||||
if(no[1][pre].point!=x)s4=no[1][pre].len;
|
||||
else s4=no[2][pre].len;
|
||||
s4=max(s4,low[pre]);
|
||||
if(no[1][x].point!=y)s4+=no[1][x].len;
|
||||
else s4+=no[2][x].len;
|
||||
if(pre!=0)s4++;
|
||||
return max(max(s1,s2),max(s3,s4));
|
||||
}
|
||||
void spfa(int x,int pre)
|
||||
{
|
||||
int visit[maxn];
|
||||
memset(visit,0,sizeof(visit));
|
||||
queue<int>q;
|
||||
queue<int>qp;
|
||||
q.push(x);
|
||||
qp.push(pre);
|
||||
visit[x]=1;
|
||||
while(!q.empty())
|
||||
{
|
||||
x=q.front();
|
||||
q.pop();
|
||||
pre=qp.front();
|
||||
qp.pop();
|
||||
for(int i=head[x]; i!=-1; i=node[i].next)
|
||||
{
|
||||
int y=node[i].v;
|
||||
if(y==pre)continue;
|
||||
h[y]=chu(pre,x,y);
|
||||
int ss=max(h[y],f[y])*node[i].w;
|
||||
if(ss<maxx)
|
||||
{
|
||||
maxx=ss;
|
||||
ipos=node[i].number;
|
||||
}
|
||||
else if(ss==maxx)ipos=min(ipos,node[i].number);
|
||||
q.push(y);
|
||||
qp.push(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
void panlow(int x,int pre)
|
||||
{
|
||||
for(int i=head[x]; i!=-1; i=node[i].next)
|
||||
{
|
||||
int y=node[i].v;
|
||||
if(y==pre)continue;
|
||||
if(y!=no[1][x].point)
|
||||
{
|
||||
low[y]=max(no[1][x].len+1,low[x]+1);
|
||||
}
|
||||
else low[y]=max(no[2][x].len+1,low[x]+1);
|
||||
panlow(y,x);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,T;
|
||||
scanf("%d",&T);
|
||||
for(t=1; t<=T; t++)
|
||||
{
|
||||
init();
|
||||
if(dfs(1,0));
|
||||
panlow(1,0);
|
||||
spfa(1,0);
|
||||
printf("Case #%d: %d\n",t,ipos);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,336 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<cstring>
|
||||
#define L x->c[0]
|
||||
#define R x->c[1]
|
||||
#define KT root->c[1]->c[0]
|
||||
using namespace std;
|
||||
const int maxn = 300010;
|
||||
const int inf = 1000000007;
|
||||
int n,Type;
|
||||
int gcd(int a,int b)
|
||||
{
|
||||
if(a<0||a>=inf) return b;
|
||||
if(b<0||b>=inf) return a;
|
||||
return b == 0?a:gcd(b,a%b);
|
||||
}
|
||||
struct Node
|
||||
{
|
||||
struct Node *c[2],*fa;
|
||||
int id,size,g,val,who;
|
||||
}S[maxn],*null = &S[0];
|
||||
Node* Q[maxn];
|
||||
Node* ID[maxn];
|
||||
int scnt;
|
||||
struct snode
|
||||
{
|
||||
int type;
|
||||
Node*root;
|
||||
inline Node *NewNode(int value,Node *p)
|
||||
{
|
||||
Node *e = S+(++scnt);
|
||||
e->val = value;
|
||||
e->id = scnt;
|
||||
e->size = 1;
|
||||
e->fa = p;
|
||||
e->g = value;
|
||||
e->c[0] = e->c[1] = null;
|
||||
ID[scnt] = e;
|
||||
return e;
|
||||
}
|
||||
inline void Update(Node *p)
|
||||
{
|
||||
p->size = p->c[0]->size+p->c[1]->size+1;
|
||||
p->g = gcd(p->c[0]->g,p->c[1]->g);
|
||||
p->g = gcd(p->val,p->g);
|
||||
}
|
||||
inline void Rotate(Node *x,int k)
|
||||
{
|
||||
Node *y=x->fa;
|
||||
y->c[k]=x->c[!k];
|
||||
y->c[k]->fa=y;
|
||||
x->fa=y->fa;
|
||||
if(y->fa->c[0]==y)
|
||||
y->fa->c[0]=x;
|
||||
else
|
||||
y->fa->c[1]=x;
|
||||
y->fa=x;
|
||||
x->c[!k]=y;
|
||||
Update(y);
|
||||
Update(x);
|
||||
if(root==y) root=x;
|
||||
}
|
||||
inline void Splay(Node *x,Node *y)
|
||||
{
|
||||
while(x->fa!=y)
|
||||
{
|
||||
if(x->fa->fa==y)
|
||||
{
|
||||
if(x->fa->c[0]==x)
|
||||
Rotate(x,0);
|
||||
else
|
||||
Rotate(x,1);
|
||||
}
|
||||
else if(x->fa->fa->c[0]==x->fa)
|
||||
{
|
||||
if(x->fa->c[0]==x)
|
||||
Rotate(x->fa,0),Rotate(x,0);
|
||||
else
|
||||
Rotate(x,1),Rotate(x,0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(x->fa->c[1]==x)
|
||||
Rotate(x->fa,1),Rotate(x,1);
|
||||
else
|
||||
Rotate(x,0),Rotate(x,1);
|
||||
}
|
||||
}
|
||||
Update(x);
|
||||
}
|
||||
inline void Select(int k,Node *y)
|
||||
{
|
||||
Node *x=root;
|
||||
while(k!=x->c[0]->size+1)
|
||||
{
|
||||
if(k<=x->c[0]->size)
|
||||
x=x->c[0];
|
||||
else
|
||||
{
|
||||
k-=x->c[0]->size+1;
|
||||
x=x->c[1];
|
||||
}
|
||||
}
|
||||
Splay(x,y);
|
||||
}
|
||||
inline void Init(int v)
|
||||
{
|
||||
root = NewNode(v,null);
|
||||
type = ++Type;
|
||||
root->who = type;
|
||||
}
|
||||
inline void Delete(Node *x)
|
||||
{
|
||||
Splay(x,null);
|
||||
Node *t = root;
|
||||
if(t->c[1]!=null)
|
||||
{
|
||||
root = t->c[1];
|
||||
Select(1,null);
|
||||
root->c[0] = t->c[0];
|
||||
if(root->c[0]!=null)
|
||||
root->c[0]->fa = root;
|
||||
}
|
||||
else
|
||||
{
|
||||
root = t->c[0];
|
||||
}
|
||||
root->fa = null;
|
||||
if(root!=null)Update(root);
|
||||
}
|
||||
inline void Insert(Node *x)
|
||||
{
|
||||
x->c[0] = x->c[1] = null;
|
||||
insert(root,x);
|
||||
Splay(x,null);
|
||||
x->who = type;
|
||||
}
|
||||
inline void insert(Node* &x,Node* y)
|
||||
{
|
||||
if(x == null)
|
||||
{
|
||||
x = y;
|
||||
return;
|
||||
}
|
||||
if(y->val<=x->val)
|
||||
{
|
||||
insert(x->c[0],y);
|
||||
x->c[0]->fa = x;
|
||||
}
|
||||
else
|
||||
{
|
||||
insert(x->c[1],y);
|
||||
x->c[1]->fa = x;
|
||||
}
|
||||
Update(x);
|
||||
}
|
||||
inline void Change(Node* tmp,int v)
|
||||
{
|
||||
Delete(tmp);
|
||||
tmp->val = v;
|
||||
Insert(tmp);
|
||||
}
|
||||
inline Node *FindSucc(Node *x,int v,int opt)
|
||||
{
|
||||
if(x == null)return x;
|
||||
if(x->val == v&&opt)return x;
|
||||
else if(x->val>v)
|
||||
{
|
||||
Node *tmp = FindSucc(x->c[0],v,opt);
|
||||
return tmp == null?x:tmp;
|
||||
}
|
||||
else
|
||||
{
|
||||
return FindSucc(x->c[1],v,opt);
|
||||
}
|
||||
}
|
||||
inline Node *FindSucc(int v,int opt)
|
||||
{
|
||||
Node *tmp = FindSucc(root,v,opt);
|
||||
Splay(tmp,null);
|
||||
return tmp;
|
||||
}
|
||||
inline Node *FindPre(Node *x,int v)
|
||||
{
|
||||
if(x == null)return x;
|
||||
if(x->val<v)
|
||||
{
|
||||
Node *tmp = FindPre(x->c[1],v);
|
||||
return tmp == null?x:tmp;
|
||||
}
|
||||
else return FindPre(x->c[0],v);
|
||||
}
|
||||
inline Node *FindPre(int v)
|
||||
{
|
||||
Node* tmp = FindPre(root,v);
|
||||
Splay(tmp,null);
|
||||
return tmp;
|
||||
}
|
||||
inline void Merge(snode &tree)
|
||||
{
|
||||
int head,tail;
|
||||
head = tail = 0;
|
||||
tree.Select(1,null);
|
||||
tree.Select(tree.root->size,tree.root);
|
||||
Q[++tail] = tree.KT;
|
||||
while(head<tail)
|
||||
{
|
||||
Node* f = Q[++head];
|
||||
if(f->c[0]!=null)Q[++tail] = f->c[0];
|
||||
if(f->c[1]!=null)Q[++tail] = f->c[1];
|
||||
Insert(f);
|
||||
f->who = type;
|
||||
}
|
||||
tree.KT = null;
|
||||
tree.Update(tree.root->c[1]);
|
||||
tree.Update(tree.root);
|
||||
}
|
||||
inline int SolveTri()
|
||||
{
|
||||
if(root->size<=4)return root->size-2;
|
||||
Select(2,null);
|
||||
int a = root->val;
|
||||
Select(3,null);
|
||||
int b = root->val;
|
||||
int ans = 2;
|
||||
while(true)
|
||||
{
|
||||
if(a+b>=inf)break;
|
||||
int c = FindSucc(a+b,1)->val;
|
||||
if(c>=inf||c == -1)break;
|
||||
a = b;
|
||||
b = c;
|
||||
ans++;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
inline int SolveGcd(int l,int r)
|
||||
{
|
||||
Node *pre = FindPre(l);
|
||||
Node *succ = FindSucc(r,0);
|
||||
Splay(pre,null);
|
||||
Splay(succ,root);
|
||||
return KT->g;
|
||||
}
|
||||
void vist(Node *x)
|
||||
{
|
||||
if(x != null)
|
||||
{
|
||||
printf("root %2d: left-son: %2d right-son: %2d size:%2d val=%2d gcd: %2d\n",x->id,x->c[0]->id,x->c[1]->id,x->size,x->val,x->g);
|
||||
vist(x->c[0]);
|
||||
vist(x->c[1]);
|
||||
}
|
||||
}
|
||||
}spt[maxn];
|
||||
void prepare()
|
||||
{
|
||||
null->id = 0;
|
||||
null->c[0] = null->c[1] = null->fa = NULL;
|
||||
null->size = null->val = 0;
|
||||
null->g = -1;
|
||||
Type = 0;
|
||||
scnt = 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,n,m,a,u,v,op,l,r,x,cas = 1;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
prepare();
|
||||
printf("Case #%d:\n",cas++);
|
||||
scanf("%d%d",&n,&m);
|
||||
for(int i = 1;i<=n;i++)
|
||||
{
|
||||
spt[i].Init(-1);
|
||||
Node *tmp = spt[i].NewNode(inf,null);
|
||||
spt[i].Insert(tmp);
|
||||
}
|
||||
for(int i = 1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
Node *tmp = spt[i].NewNode(a,null);
|
||||
spt[i].Insert(tmp);
|
||||
}
|
||||
int tot = 0;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d",&op);
|
||||
if(op == 1)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
Node *t1 = ID[u+2*n];
|
||||
Node *t2 = ID[v+2*n];
|
||||
int tree1 = t1->who;
|
||||
int tree2 = t2->who;
|
||||
if(tree1 == tree2)continue;
|
||||
int size1 = spt[tree1].root->size;
|
||||
int size2 = spt[tree2].root->size;
|
||||
if(size1>size2)spt[tree1].Merge(spt[tree2]);
|
||||
else spt[tree2].Merge(spt[tree1]);
|
||||
}
|
||||
else if(op == 2)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
Node *t1 = ID[u+2*n];
|
||||
Node *t2 = ID[v+2*n];
|
||||
int tree1 = t1->who;
|
||||
int tree2 = t2->who;
|
||||
spt[tree1].Delete(t1);
|
||||
spt[tree2].Insert(t1);
|
||||
}
|
||||
else if(op == 3)
|
||||
{
|
||||
scanf("%d%d",&u,&x);
|
||||
Node *tmp = ID[u+2*n];
|
||||
int tree = tmp->who;
|
||||
spt[tree].Change(tmp,x);
|
||||
}
|
||||
else if(op == 4)
|
||||
{
|
||||
scanf("%d",&u);
|
||||
Node *tmp = ID[u+2*n];
|
||||
int tree = tmp->who;
|
||||
printf("%d\n",spt[tree].SolveTri());
|
||||
}
|
||||
else
|
||||
{
|
||||
scanf("%d%d%d",&u,&l,&r);
|
||||
Node *tmp = ID[u+2*n];
|
||||
int tree = tmp->who;
|
||||
printf("%d\n",spt[tree].SolveGcd(l,r));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
char sta[1001];
|
||||
char stb[1001];
|
||||
char stc[1001];
|
||||
int lena,lenb,lenc;
|
||||
int dp[1001][1001];
|
||||
int dpf[1001][1001];
|
||||
struct list
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
}node,n1,n2;
|
||||
vector<list>vec[5];
|
||||
void dps()
|
||||
{
|
||||
int i,j;
|
||||
for(i=0;i<lena;i++)
|
||||
if(sta[i]==stb[0])
|
||||
for(i;i<lena;i++)dp[i][0]=1;
|
||||
for(i=0;i<lenb;i++)
|
||||
if(sta[0]==stb[i])
|
||||
for(i;i<lenb;i++)dp[0][i]=1;
|
||||
for(i=1;i<lena;i++)
|
||||
{
|
||||
for(j=1;j<lenb;j++)
|
||||
{
|
||||
if(sta[i]==stb[j])dp[i][j]=dp[i-1][j-1]+1;
|
||||
else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
void dpfs()
|
||||
{
|
||||
int i,j;
|
||||
for(i=lena-1;i>=0;i--)
|
||||
if(sta[i]==stb[lenb-1])
|
||||
for(i;i>=0;i--)dpf[i][lenb-1]=1;
|
||||
for(i=lenb-1;i>=0;i--)
|
||||
if(sta[lena-1]==stb[i])
|
||||
for(i;i>=0;i--)dpf[lena-1][i]=1;
|
||||
for(i=lena-2;i>=0;i--)
|
||||
{
|
||||
for(j=lenb-2;j>=0;j--)
|
||||
{
|
||||
if(sta[i]==stb[j])dpf[i][j]=dpf[i+1][j+1]+1;
|
||||
else dpf[i][j]=max(dpf[i+1][j],dpf[i][j+1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
void init()
|
||||
{
|
||||
memset(dp,0,sizeof(dp));
|
||||
memset(dpf,0,sizeof(dpf));
|
||||
vec[0].clear();
|
||||
vec[1].clear();
|
||||
gets(sta);
|
||||
gets(stb);
|
||||
gets(stc);
|
||||
lena=strlen(sta);
|
||||
lenb=strlen(stb);
|
||||
lenc=strlen(stc);
|
||||
}
|
||||
void sear(char str[],int pos)
|
||||
{
|
||||
int lens=strlen(str);
|
||||
int i,j,k;
|
||||
for(i=0;i<lens;i++)
|
||||
{
|
||||
if(str[i]==stc[0])
|
||||
{
|
||||
for(k=0,j=i;j<lens;j++)
|
||||
{
|
||||
if(str[j]==stc[k])k++;
|
||||
if(k==lenc)break;
|
||||
}
|
||||
if(j<lens)
|
||||
{
|
||||
node.x=i;
|
||||
node.y=j;
|
||||
vec[pos].push_back(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void prin(int cas)
|
||||
{
|
||||
int l1=vec[0].size();
|
||||
int l2=vec[1].size();
|
||||
int maxx=0;
|
||||
int i,j;
|
||||
for(i=0;i<l1;i++)
|
||||
{
|
||||
for(j=0;j<l2;j++)
|
||||
{
|
||||
n1=vec[0][i];
|
||||
n2=vec[1][j];
|
||||
int c1,c2;
|
||||
c1=c2=0;
|
||||
if(n1.x-1>=0&&n2.x-1>=0)c1=dp[n1.x-1][n2.x-1];
|
||||
if(n1.y+1<lena&&n2.y+1<lenb)c2=dpf[n1.y+1][n2.y+1];
|
||||
maxx=max(maxx,c1+c2+lenc);
|
||||
}
|
||||
}
|
||||
printf("Case #%d: %d\n",cas,maxx);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,t;
|
||||
scanf("%d%*c",&T);
|
||||
for(t=1;t<=T;t++)
|
||||
{
|
||||
init();
|
||||
dps();
|
||||
dpfs();
|
||||
sear(sta,0);
|
||||
sear(stb,1);
|
||||
prin(t);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<stack>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
#define MAXN 1111
|
||||
int n,m,N,cnt;
|
||||
bool map[MAXN][MAXN];
|
||||
bool mark[MAXN];
|
||||
int ly[MAXN];
|
||||
int lx[MAXN];
|
||||
int dfs(int u,int m)
|
||||
{
|
||||
for(int v=1;v<=m;v++){
|
||||
if(map[u][v]&&!mark[v]){
|
||||
mark[v]=true;
|
||||
if(ly[v]==-1||dfs(ly[v],m)){
|
||||
ly[v]=u;
|
||||
lx[u]=v;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int MaxMatch(int n,int m)
|
||||
{
|
||||
memset(ly,-1,sizeof(ly));
|
||||
memset(lx,-1,sizeof(lx));
|
||||
int ans=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
memset(mark,false,sizeof(mark));
|
||||
ans+=dfs(i,m);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
vector<vector<int> >g;
|
||||
vector<vector<int> >ans;
|
||||
int dfn[MAXN],low[MAXN];
|
||||
int color[MAXN],_count;
|
||||
stack<int>S;
|
||||
void Tarjan(int u)
|
||||
{
|
||||
low[u]=dfn[u]=++cnt;
|
||||
mark[u]=true;
|
||||
S.push(u);
|
||||
for(int i=0;i<g[u].size();i++){
|
||||
int v=g[u][i];
|
||||
if(dfn[v]==0){
|
||||
Tarjan(v);
|
||||
low[u]=min(low[u],low[v]);
|
||||
}else if(mark[v]){
|
||||
low[u]=min(low[u],dfn[v]);
|
||||
}
|
||||
}
|
||||
if(low[u]==dfn[u]){
|
||||
_count++;
|
||||
int x;
|
||||
do{
|
||||
x=S.top();
|
||||
S.pop();
|
||||
mark[x]=false;
|
||||
color[x]=_count;
|
||||
}while(x!=u);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int _case,k,x,t=1;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
memset(map,false,sizeof(map));
|
||||
for(int i=1;i<=n;i++){
|
||||
scanf("%d",&k);
|
||||
while(k--){
|
||||
scanf("%d",&x);
|
||||
map[i][x]=true;
|
||||
}
|
||||
}
|
||||
cnt=MaxMatch(n,m);
|
||||
N=n+m-cnt;
|
||||
for(int i=n+1;i<=N;i++)
|
||||
for(int j=1;j<=N;j++)
|
||||
map[i][j]=true;
|
||||
for(int i=m+1;i<=N;i++)
|
||||
for(int j=1;j<=N;j++)
|
||||
map[j][i]=true;
|
||||
MaxMatch(N,N);
|
||||
g.clear();
|
||||
g.resize(N+2);
|
||||
ans.clear();
|
||||
ans.resize(N+2);
|
||||
for(int i=1;i<=N;i++){
|
||||
for(int j=1;j<=N;j++){
|
||||
if(lx[i]!=j&&map[i][j]){
|
||||
g[lx[i]].push_back(j);
|
||||
}
|
||||
}
|
||||
}
|
||||
memset(dfn,0,sizeof(dfn));
|
||||
memset(mark,false,sizeof(mark));
|
||||
_count=cnt=0;
|
||||
for(int i=1;i<=N;i++)
|
||||
if(dfn[i]==0)Tarjan(i);
|
||||
for(int i=1;i<=n;i++){
|
||||
for(int j=1;j<=m;j++){
|
||||
if(map[i][j]&&color[lx[i]]==color[j]){
|
||||
ans[i].push_back(j);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case #%d:\n",t++);
|
||||
for(int i=1;i<=n;i++){
|
||||
printf("%d",(int)ans[i].size());
|
||||
for(int j=0;j<ans[i].size();j++){
|
||||
printf(" %d",ans[i][j]);
|
||||
}
|
||||
puts("");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define LL long long
|
||||
#define M 1000000007
|
||||
struct Matrix
|
||||
{
|
||||
LL a[6][6];
|
||||
}origin,res,tmp,A,ans;
|
||||
int n;
|
||||
Matrix mul(Matrix x,Matrix y)
|
||||
{
|
||||
int i,j,k;
|
||||
memset(tmp.a,0,sizeof(tmp.a));
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
for(k=1;k<=n;k++)
|
||||
{
|
||||
tmp.a[i][j]+=(x.a[i][k]*y.a[k][j])%M;
|
||||
tmp.a[i][j]%=M;
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
void quickpow(LL k)
|
||||
{
|
||||
int i;
|
||||
memset(res.a,0,sizeof(res.a));
|
||||
for(i=1;i<=n;i++)
|
||||
res.a[i][i]=1;
|
||||
while(k)
|
||||
{
|
||||
if(k&1)
|
||||
res=mul(res,A);
|
||||
A=mul(A,A);
|
||||
k>>=1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
LL N,a0,ax,ay,b0,bx,by;
|
||||
LL f1,a1,b1,s0;
|
||||
while(scanf("%lld %lld %lld %lld %lld %lld %lld",&N,&a0,&ax,&ay,&b0,&bx,&by)!=EOF)
|
||||
{
|
||||
if(N==0)
|
||||
{
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
a1=(a0*ax+ay)%M;
|
||||
b1=(b0*bx+by)%M;
|
||||
f1=(a1*b1)%M;
|
||||
s0=(a0*b0)%M;
|
||||
n=5;
|
||||
memset(origin.a,0,sizeof(origin.a));
|
||||
origin.a[1][1]=f1;
|
||||
origin.a[1][2]=a1;
|
||||
origin.a[1][3]=b1;
|
||||
origin.a[1][4]=1;
|
||||
origin.a[1][5]=s0;
|
||||
memset(A.a,0,sizeof(A.a));
|
||||
A.a[1][1]=(ax*bx)%M;
|
||||
A.a[1][5]=1;
|
||||
A.a[2][1]=(ax*by)%M;
|
||||
A.a[2][2]=ax%M;
|
||||
A.a[3][1]=(ay*bx)%M;
|
||||
A.a[3][3]=bx%M;
|
||||
A.a[4][1]=(ay*by)%M;
|
||||
A.a[4][2]=ay%M;
|
||||
A.a[4][3]=by%M;
|
||||
A.a[4][4]=1;
|
||||
A.a[5][5]=1;
|
||||
quickpow(N-1);
|
||||
ans=mul(origin,res);
|
||||
printf("%lld\n",ans.a[1][5]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,187 @@
|
|||
#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 = 50;
|
||||
int N;
|
||||
bool Graph[MAXN][MAXN];
|
||||
int Match[MAXN];
|
||||
bool InQueue[MAXN],InPath[MAXN],InBlossom[MAXN];
|
||||
int Head,Tail;
|
||||
int Queue[MAXN];
|
||||
int Start,Finish;
|
||||
int NewBase;
|
||||
int Father[MAXN],Base[MAXN];
|
||||
int Count;
|
||||
void Push(int u)
|
||||
{
|
||||
Queue[Tail] = u;
|
||||
Tail++;
|
||||
InQueue[u] = true;
|
||||
}
|
||||
int Pop()
|
||||
{
|
||||
int res = Queue[Head];
|
||||
Head++;
|
||||
return res;
|
||||
}
|
||||
int FindCommonAncestor(int u,int v)
|
||||
{
|
||||
memset(InPath,false,sizeof(InPath));
|
||||
while(true)
|
||||
{
|
||||
u = Base[u];
|
||||
InPath[u] = true;
|
||||
if(u == Start) break;
|
||||
u = Father[Match[u]];
|
||||
}
|
||||
while(true)
|
||||
{
|
||||
v = Base[v];
|
||||
if(InPath[v])break;
|
||||
v = Father[Match[v]];
|
||||
}
|
||||
return v;
|
||||
}
|
||||
void ResetTrace(int u)
|
||||
{
|
||||
int v;
|
||||
while(Base[u] != NewBase)
|
||||
{
|
||||
v = Match[u];
|
||||
InBlossom[Base[u]] = InBlossom[Base[v]] = true;
|
||||
u = Father[v];
|
||||
if(Base[u] != NewBase) Father[u] = v;
|
||||
}
|
||||
}
|
||||
void BloosomContract(int u,int v)
|
||||
{
|
||||
NewBase = FindCommonAncestor(u,v);
|
||||
memset(InBlossom,false,sizeof(InBlossom));
|
||||
ResetTrace(u);
|
||||
ResetTrace(v);
|
||||
if(Base[u] != NewBase) Father[u] = v;
|
||||
if(Base[v] != NewBase) Father[v] = u;
|
||||
for(int tu = 1; tu <= N; tu++)
|
||||
if(InBlossom[Base[tu]])
|
||||
{
|
||||
Base[tu] = NewBase;
|
||||
if(!InQueue[tu]) Push(tu);
|
||||
}
|
||||
}
|
||||
void FindAugmentingPath()
|
||||
{
|
||||
memset(InQueue,false,sizeof(InQueue));
|
||||
memset(Father,0,sizeof(Father));
|
||||
for(int i = 1;i <= N;i++)
|
||||
Base[i] = i;
|
||||
Head = Tail = 1;
|
||||
Push(Start);
|
||||
Finish = 0;
|
||||
while(Head < Tail)
|
||||
{
|
||||
int u = Pop();
|
||||
for(int v = 1; v <= N; v++)
|
||||
if(Graph[u][v] && (Base[u] != Base[v]) && (Match[u] != v))
|
||||
{
|
||||
if((v == Start) || ((Match[v] > 0) && Father[Match[v]] > 0))
|
||||
BloosomContract(u,v);
|
||||
else if(Father[v] == 0)
|
||||
{
|
||||
Father[v] = u;
|
||||
if(Match[v] > 0)
|
||||
Push(Match[v]);
|
||||
else
|
||||
{
|
||||
Finish = v;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void AugmentPath()
|
||||
{
|
||||
int u,v,w;
|
||||
u = Finish;
|
||||
while(u > 0)
|
||||
{
|
||||
v = Father[u];
|
||||
w = Match[v];
|
||||
Match[v] = u;
|
||||
Match[u] = v;
|
||||
u = w;
|
||||
}
|
||||
}
|
||||
void Edmonds()
|
||||
{
|
||||
memset(Match,0,sizeof(Match));
|
||||
for(int u = 1; u <= N; u++)
|
||||
if(Match[u] == 0)
|
||||
{
|
||||
Start = u;
|
||||
FindAugmentingPath();
|
||||
if(Finish > 0)AugmentPath();
|
||||
}
|
||||
}
|
||||
int getMatch()
|
||||
{
|
||||
Edmonds();
|
||||
Count = 0;
|
||||
for(int u = 1; u <= N;u++)
|
||||
if(Match[u] > 0)
|
||||
Count++;
|
||||
return Count/2;
|
||||
}
|
||||
bool g[MAXN][MAXN];
|
||||
pair<int,int>p[150];
|
||||
int main()
|
||||
{
|
||||
int m;
|
||||
while(scanf("%d%d",&N,&m)==2)
|
||||
{
|
||||
memset(g,false,sizeof(g));
|
||||
memset(Graph,false,sizeof(Graph));
|
||||
int u,v;
|
||||
for(int i = 1;i <= m;i++)
|
||||
{
|
||||
scanf("%d%d",&u,&v);
|
||||
p[i] = make_pair(u,v);
|
||||
g[u][v] = true;
|
||||
g[v][u] = true;
|
||||
Graph[u][v] = true;
|
||||
Graph[v][u] = true;
|
||||
}
|
||||
int cnt0 = getMatch();
|
||||
vector<int>ans;
|
||||
for(int i = 1;i <= m;i++)
|
||||
{
|
||||
u = p[i].first;
|
||||
v = p[i].second;
|
||||
memcpy(Graph,g,sizeof(g));
|
||||
for(int j = 1;j <= N;j++)
|
||||
Graph[j][u] = Graph[u][j] = Graph[j][v] = Graph[v][j] = false;
|
||||
int cnt = getMatch();
|
||||
if(cnt < cnt0-1)
|
||||
ans.push_back(i);
|
||||
}
|
||||
int sz = ans.size();
|
||||
printf("%d\n",sz);
|
||||
for(int i = 0;i < sz;i++)
|
||||
{
|
||||
printf("%d",ans[i]);
|
||||
if(i < sz-1)printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define ll long long
|
||||
char a[100];
|
||||
ll dp[22][22][22];
|
||||
int main ()
|
||||
{
|
||||
while(scanf("%s",a)!=EOF)
|
||||
{
|
||||
if(a[0]=='-')
|
||||
{
|
||||
printf("0\n");
|
||||
continue;
|
||||
}
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[1][0][1]=1;
|
||||
int cnt=0;
|
||||
for(int i=1;i<strlen(a);++i)
|
||||
{
|
||||
if(a[i]=='-')
|
||||
{
|
||||
cnt++;
|
||||
for(int j=0;j<i;++j)
|
||||
for(int k=0;k<=i;++k)
|
||||
{
|
||||
if(i-j-k>0)
|
||||
dp[i+1][j+1][k]+=dp[i][j][k]*(i-j-k);
|
||||
if(k)
|
||||
dp[i+1][j+1][k-1]+=dp[i][j][k]*k;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int j=0;j<=i;++j)
|
||||
for(int k=0;k<=i;++k)
|
||||
{
|
||||
dp[i+1][j][k+1]+=dp[i][j][k];
|
||||
if(i-j-k>0)
|
||||
dp[i+1][j][k+1]+=dp[i][j][k]*(i-j-k);
|
||||
dp[i+1][j][k]+=dp[i][j][k]*k;
|
||||
}
|
||||
}
|
||||
}
|
||||
cout<<dp[strlen(a)][cnt][0]<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <cctype>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <deque>
|
||||
#include <queue>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
#include <functional>
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <numeric>
|
||||
#include <cassert>
|
||||
#include <ctime>
|
||||
#include <iterator>
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int dir[8][2] = {{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{-1,1},{1,-1},{1,1}};
|
||||
using namespace std;
|
||||
string A[16][16] = {
|
||||
"NUL","SOH","STX","ETX","","HT","","DEL","","","","VT","FF","CR","SO","SI",
|
||||
"DLE","DC1","DC2","DC3","","","BS","","CAN","EM","","","IFS","IGS","IRS","IUS ITB",
|
||||
"","","","","","LF","ETB","ESC","","","","","","ENQ","ACK","BEL",
|
||||
"","","SYN","","","","","EOT","","","","","DC4","NAK","","SUB",
|
||||
"SP","","","","","","","","","","",".","<","(","+","|",
|
||||
"&","","","","","","","","","","!","$","*",")",";","",
|
||||
"-","/","","","","","","","","","",",","%","_",">","?",
|
||||
"","","","","","","","","","`",":","#","@","'","=","\"",
|
||||
"","a","b","c","d","e","f","g","h","i","","","","","","",
|
||||
"","j","k","l","m","n","o","p","q","r","","","","","","",
|
||||
"","~","s","t","u","v","w","x","y","z","","","","","","",
|
||||
"^","","","","","","","","","","[","]","","","","",
|
||||
"{","A","B","C","D","E","F","G","H","I","","","","","","",
|
||||
"}","J","K","L","M","N","O","P","Q","R","","","","","","",
|
||||
"\\","","S","T","U","V","W","X","Y","Z","","","","","","",
|
||||
"0","1","2","3","4","5","6","7","8","9","","","","","",""
|
||||
};
|
||||
string B[8][16] = {
|
||||
"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
|
||||
"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IFS", "IGS", "IRS", "IUS ITB",
|
||||
"SP", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/",
|
||||
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?",
|
||||
"@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
|
||||
"P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\","]","^","_",
|
||||
"`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
|
||||
"p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "DEL"
|
||||
};
|
||||
map<pair<int,int>, pair<int,int> > coll;
|
||||
int main(void)
|
||||
{
|
||||
string sad;
|
||||
ios::sync_with_stdio(false);
|
||||
cin>>sad; coll.clear();
|
||||
string tmp; pair<int,int> so, to;
|
||||
for (int i = 0; i < 16; ++i)
|
||||
{
|
||||
for (int j = 0; j < 16; ++j)
|
||||
{
|
||||
if (A[i][j]!="")
|
||||
{
|
||||
so.first=i, so.second=j;
|
||||
bool mrk = false;
|
||||
for (int k = 0; k < 8; ++k)
|
||||
{
|
||||
for (int h = 0; h < 16; ++h)
|
||||
{
|
||||
if (A[i][j]==B[k][h])
|
||||
{
|
||||
mrk = true;
|
||||
to.first=k,to.second=h;
|
||||
coll[so] = to; break;
|
||||
}
|
||||
}
|
||||
if (mrk) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < sad.size(); i+=2)
|
||||
{
|
||||
int X, Y; tmp.clear();
|
||||
if (sad[i]>='A'&&sad[i]<='F') X = sad[i]- 'A'+10;
|
||||
else X = sad[i] - '0';
|
||||
if (sad[i+1]>='A'&&sad[i+1]<='F') Y = sad[i+1]- 'A'+10;
|
||||
else Y = sad[i+1] - '0';
|
||||
pair<int,int> hehe, TM;
|
||||
hehe.first = X, hehe.second = Y;
|
||||
TM = coll[hehe];
|
||||
int j = TM.first, k = TM.second;
|
||||
char XX, YY;
|
||||
XX = j+ '0';
|
||||
if (k >= 10) YY = k - 10 + 'A';
|
||||
else YY = k + '0';
|
||||
printf("%c%c", XX, YY);
|
||||
}
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
#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 t1[MAXN],t2[MAXN],c[MAXN];
|
||||
bool cmp(int *r,int a,int b,int l)
|
||||
{
|
||||
return r[a] == r[b] && r[a+l] == r[b+l];
|
||||
}
|
||||
void da(int str[],int sa[],int ran[],int height[],int n,int m)
|
||||
{
|
||||
n++;
|
||||
int i, j, p, *x = t1, *y = t2;
|
||||
for(i = 0;i < m;i++)c[i] = 0;
|
||||
for(i = 0;i < n;i++)c[x[i] = str[i]]++;
|
||||
for(i = 1;i < m;i++)c[i] += c[i-1];
|
||||
for(i = n-1;i >= 0;i--)sa[--c[x[i]]] = i;
|
||||
for(j = 1;j <= n; j <<= 1)
|
||||
{
|
||||
p = 0;
|
||||
for(i = n-j; i < n; i++)y[p++] = i;
|
||||
for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
|
||||
for(i = 0; i < m; i++)c[i] = 0;
|
||||
for(i = 0; i < n; i++)c[x[y[i]]]++;
|
||||
for(i = 1; i < m;i++)c[i] += c[i-1];
|
||||
for(i = n-1; i >= 0;i--)sa[--c[x[y[i]]]] = y[i];
|
||||
swap(x,y);
|
||||
p = 1; x[sa[0]] = 0;
|
||||
for(i = 1;i < n;i++)
|
||||
x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
|
||||
if(p >= n)break;
|
||||
m = p;
|
||||
}
|
||||
int k = 0;
|
||||
n--;
|
||||
for(i = 0;i <= n;i++)ran[sa[i]] = i;
|
||||
for(i = 0;i < n;i++)
|
||||
{
|
||||
if(k)k--;
|
||||
j = sa[ran[i]-1];
|
||||
while(str[i+k] == str[j+k])k++;
|
||||
height[ran[i]] = k;
|
||||
}
|
||||
}
|
||||
int ran[MAXN],height[MAXN];
|
||||
int RMQ[MAXN];
|
||||
int mm[MAXN];
|
||||
int best[20][MAXN];
|
||||
void initRMQ(int n)
|
||||
{
|
||||
mm[0]=-1;
|
||||
for(int i=1;i<=n;i++)
|
||||
mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
|
||||
for(int i=1;i<=n;i++)best[0][i]=i;
|
||||
for(int i=1;i<=mm[n];i++)
|
||||
for(int j=1;j+(1<<i)-1<=n;j++)
|
||||
{
|
||||
int a=best[i-1][j];
|
||||
int b=best[i-1][j+(1<<(i-1))];
|
||||
if(RMQ[a]<RMQ[b])best[i][j]=a;
|
||||
else best[i][j]=b;
|
||||
}
|
||||
}
|
||||
int askRMQ(int a,int b)
|
||||
{
|
||||
int t;
|
||||
t=mm[b-a+1];
|
||||
b-=(1<<t)-1;
|
||||
a=best[t][a];b=best[t][b];
|
||||
return RMQ[a]<RMQ[b]?a:b;
|
||||
}
|
||||
int lcp(int a,int b)
|
||||
{
|
||||
a=ran[a];b=ran[b];
|
||||
if(a>b)swap(a,b);
|
||||
return height[askRMQ(a+1,b)];
|
||||
}
|
||||
char str[MAXN];
|
||||
int r[MAXN];
|
||||
int sa[MAXN];
|
||||
int A[MAXN],B[MAXN];
|
||||
int calc(int n)
|
||||
{
|
||||
if(n == 0)return 1;
|
||||
int ret = 0;
|
||||
while(n)
|
||||
{
|
||||
ret++;
|
||||
n /= 10;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%s",str)==1)
|
||||
{
|
||||
int n = strlen(str);
|
||||
for(int i = 0;i < n;i++)
|
||||
r[i] = str[i];
|
||||
r[n] = 0;
|
||||
da(r,sa,ran,height,n,128);
|
||||
for(int i = 1;i <= n;i++)
|
||||
RMQ[i] = height[i];
|
||||
initRMQ(n);
|
||||
int k,u,v;
|
||||
long long ans1 = 0, ans2 = 0;
|
||||
scanf("%d",&k);
|
||||
for(int i = 0;i < k;i++)
|
||||
{
|
||||
scanf("%d%d",&A[i],&B[i]);
|
||||
if(i == 0)
|
||||
{
|
||||
ans1 += B[i] - A[i] + 1;
|
||||
ans2 += B[i] - A[i] + 3;
|
||||
continue;
|
||||
}
|
||||
int tmp ;
|
||||
if(A[i]!= A[i-1])tmp = lcp(A[i],A[i-1]);
|
||||
else tmp = 10000000;
|
||||
tmp = min(tmp,B[i]-A[i]);
|
||||
tmp = min(tmp,B[i-1]-A[i-1]);
|
||||
ans1 += B[i] - A[i] + 1;
|
||||
ans2 += B[i] - A[i] - tmp + 1;
|
||||
ans2 += 1;
|
||||
ans2 += calc(tmp);
|
||||
}
|
||||
printf("%I64d %I64d\n",ans1,ans2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
#define LL __int64
|
||||
#define maxn 100011
|
||||
int t[maxn],c[maxn],n,q,m[maxn],vis[maxn],a[maxn],b[maxn];
|
||||
map<int,map<int,int> >nn;
|
||||
map<int,int>mm;
|
||||
map<int,int>ll;
|
||||
int bb[1001];
|
||||
int flag[maxn],s[maxn],ss[maxn];
|
||||
void find(int x)
|
||||
{
|
||||
ll.clear();
|
||||
int tt=1,i,j,k,y,z,d;
|
||||
s[0]=0;s[1]=c[x];ll[x]=1,ss[1]=x;
|
||||
for(i=2;;i++)
|
||||
{
|
||||
vis[x]=1;
|
||||
x=t[x];
|
||||
ss[i]=x;
|
||||
if(ll[x])
|
||||
break;
|
||||
if(vis[x])
|
||||
{
|
||||
for(j=i-1;j>=1;j--)
|
||||
{
|
||||
a[ss[j]]=s[i-1]-s[j-1]+a[x];
|
||||
b[ss[j]]=b[x];
|
||||
}
|
||||
return;
|
||||
}
|
||||
ll[x]=++tt;
|
||||
s[i]=s[i-1]+c[x];
|
||||
}
|
||||
d=s[i-1]-s[ll[x]-1];
|
||||
for(j=1;j<i;j++)
|
||||
{
|
||||
if(j<=ll[x])
|
||||
a[ss[j]]=s[ll[x]-1]-s[j-1];
|
||||
else
|
||||
a[ss[j]]=s[i-1]-s[j-1];
|
||||
b[ss[j]]=d;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&q)!=EOF)
|
||||
{
|
||||
int i,j,k;
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&t[i]);
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&c[i]);
|
||||
for(i=1;i<=q;i++)
|
||||
scanf("%d",&m[i]);
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(!vis[i])
|
||||
find(i);
|
||||
}
|
||||
mm.clear();
|
||||
nn.clear();
|
||||
int tt=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(mm[b[i]]==0)
|
||||
{
|
||||
mm[b[i]]=++tt;
|
||||
bb[tt]=b[i];
|
||||
}
|
||||
nn[tt][a[i]]=1;
|
||||
}
|
||||
memset(flag,0,sizeof(flag));
|
||||
for(j=1;j<=q;j++)
|
||||
{
|
||||
if(m[j]<=0)continue;
|
||||
for(i=1;i<=tt;i++)
|
||||
if(nn[i][m[j]%bb[i]]){flag[j]=1;break;}
|
||||
}
|
||||
for(i=1;i<=q;i++)
|
||||
if(flag[i])printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-9;
|
||||
inline int dcmp(double x) {
|
||||
if (fabs(x) < eps)
|
||||
return 0;
|
||||
return x > eps ? 1 : -1;
|
||||
}
|
||||
struct point {
|
||||
double x, y;
|
||||
int id;
|
||||
inline void in(int i) {
|
||||
scanf("%lf%lf", &x, &y);
|
||||
id = i;
|
||||
}
|
||||
point(double x = 0, double y = 0) :
|
||||
x(x), y(y) {
|
||||
}
|
||||
inline point operator -(const point &t) const {
|
||||
return point(x - t.x, y - t.y);
|
||||
}
|
||||
inline point operator +(const point &t) const {
|
||||
return point(x + t.x, y + t.y);
|
||||
}
|
||||
point operator /(const double &t) const {
|
||||
return point(x / t, y / t);
|
||||
}
|
||||
point operator *(const double &t) const {
|
||||
return point(x * t, y * t);
|
||||
}
|
||||
inline double operator *(const point &t) const {
|
||||
return x*t.y-y*t.x;
|
||||
}
|
||||
bool operator <(const point &t) const {
|
||||
if(y == t.y) return x < t.x;
|
||||
return y < t.y;
|
||||
}
|
||||
}p[55], v[55], tp[55], st[55];
|
||||
double t[55*55*55], T, cur, ans;
|
||||
int sz, n, m;
|
||||
double a, b, c;
|
||||
inline double cross(const point &o, const point &a, const point &b) {
|
||||
return (a.x-o.x)*(b.y-o.y)-(a.y-o.y)*(b.x-o.x);
|
||||
}
|
||||
int graham(point *p, int n, point *st) {
|
||||
sort(p, p + n);
|
||||
int top = 0;
|
||||
int i;
|
||||
for (i = 0; i < n; i++) {
|
||||
while (top >= 2 && cross(st[top - 2], st[top - 1], p[i]) < eps)
|
||||
top--;
|
||||
st[top++] = p[i];
|
||||
}
|
||||
int t = top + 1;
|
||||
for (i = n - 2; i >= 0; i--) {
|
||||
while (top >= t && cross(st[top - 2], st[top - 1], p[i]) < eps)
|
||||
top--;
|
||||
st[top++] = p[i];
|
||||
}
|
||||
return top;
|
||||
}
|
||||
inline void gao(int i, int j, int k) {
|
||||
point a1 = p[i]-p[j], a2 = p[i]-p[k];
|
||||
point b1 = v[i]-v[j], b2 = v[i]-v[k];
|
||||
a += b1*b2; b += a1*b2+b1*a2; c += a1*a2;
|
||||
}
|
||||
inline void solve(double a, double b, double c) {
|
||||
double x;
|
||||
if(a == 0) {
|
||||
if(b!= 0) {
|
||||
x = -c/b;
|
||||
if(x >= 0 && x <= T) t[sz++] = x;
|
||||
}
|
||||
return;
|
||||
}
|
||||
double dlt = b*b-4*a*c;
|
||||
if(dlt < 0) return;
|
||||
if(dlt == 0) {
|
||||
x = -b*0.5/a;
|
||||
if(x >= 0 && x <= T) t[sz++] = x;
|
||||
return;
|
||||
}
|
||||
dlt = sqrt(dlt);
|
||||
x = 0.5*(-b+dlt)/a;
|
||||
if(x >= 0 && x <= T) t[sz++] = x;
|
||||
x = 0.5*(-b-dlt)/a;
|
||||
if(x >= 0 && x <= T) t[sz++] = x;
|
||||
}
|
||||
inline double F(double x) {
|
||||
return a*x*x*x/3.0+b*x*x/2.0+c*x;
|
||||
}
|
||||
int main() {
|
||||
int i, j, k;
|
||||
while( ~scanf("%d%lf", &n, &T)) {
|
||||
for(i = 0; i < n; i++) p[i].in(i), v[i].in(i);
|
||||
if(n <= 2) {
|
||||
printf("%.10f\n", 0.0);
|
||||
continue;
|
||||
}
|
||||
t[0] = 0; t[1] = T;
|
||||
sz = 2;
|
||||
for(i = 0; i < n; i++)
|
||||
for(j = i+1; j < n; j++)
|
||||
for(k = j+1; k < n; k++) {
|
||||
a = b = c = 0;
|
||||
gao(i, j, k);
|
||||
solve(a, b, c);
|
||||
}
|
||||
sort(t, t+sz);
|
||||
ans = 0;
|
||||
for(i = 0; i < sz-1; i++) {
|
||||
cur = 0.5*(t[i]+t[i+1]);
|
||||
a = b = c = 0;
|
||||
for(j = 0; j < n; j++) {
|
||||
tp[j] = p[j]+v[j]*cur;
|
||||
tp[j].id = p[j].id;
|
||||
}
|
||||
m = graham(tp, n, st);
|
||||
for(j = 2; j < m; j++)
|
||||
gao(st[0].id, st[j-1].id, st[j].id);
|
||||
ans += F(t[i+1])- F(t[i]);
|
||||
}
|
||||
printf("%.10f\n", fabs(ans*0.5/T));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#define LL long long
|
||||
#define mod 1000000007
|
||||
#define M 1005
|
||||
#define INF 0x7fffffff
|
||||
using namespace std;
|
||||
struct Point
|
||||
{
|
||||
int x, y;
|
||||
bool operator < (const Point &temp) const
|
||||
{
|
||||
if(x!=temp.x) return x<temp.x;
|
||||
else return y<temp.y;
|
||||
}
|
||||
int readPoint()
|
||||
{
|
||||
return scanf("%d%d", &x, &y);
|
||||
}
|
||||
} p[M];
|
||||
int n, m, k;
|
||||
int val[M];
|
||||
set<int>sset;
|
||||
set<int>::iterator it;
|
||||
int main ()
|
||||
{
|
||||
while(~scanf("%d%d%d", &n, &m, &k))
|
||||
{
|
||||
for(int i = 1; i <= k; ++i)
|
||||
{
|
||||
p[i].readPoint();
|
||||
val[i] = p[i].x;
|
||||
}
|
||||
sort(p+1, p+1+k);
|
||||
sort(val+1, val+1+k);
|
||||
int tot = unique(val+1, val+1+k) - val;
|
||||
val[0] = 0;
|
||||
val[tot] = n+1;
|
||||
LL ans = 0;
|
||||
for(int i = 1; i < tot; ++i)
|
||||
{
|
||||
LL tt = 0;
|
||||
int pre = val[i]-val[i-1];
|
||||
int r;
|
||||
for(r = 1; r <= k && p[r].x < val[i]; ++r);
|
||||
sset.clear();
|
||||
sset.insert(0);
|
||||
sset.insert(m+1);
|
||||
for(int j = i; j < tot; ++j)
|
||||
{
|
||||
int top, bottom;
|
||||
for( ; r <= k && p[r].x == val[j]; ++r)
|
||||
{
|
||||
if(sset.count(p[r].y)) continue;
|
||||
it = sset.lower_bound(p[r].y);
|
||||
top = *it;
|
||||
bottom = *(--it);
|
||||
tt = (tt+(LL)(top-p[r].y)*(p[r].y-bottom)%mod)%mod;
|
||||
sset.insert(p[r].y);
|
||||
}
|
||||
int rear = val[j+1]-val[j];
|
||||
ans = (ans+tt*rear%mod*pre%mod)%mod;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
#define max(a,b) a>b?a:b
|
||||
#define min(a,b) a<b?a:b
|
||||
struct node
|
||||
{
|
||||
int sum;
|
||||
int m;
|
||||
int v;
|
||||
}ne,cur;
|
||||
vector<node>a,b;
|
||||
int main()
|
||||
{
|
||||
int num,j,n;
|
||||
char k;
|
||||
while(scanf("%d",&num)!=EOF)
|
||||
{
|
||||
a.clear();
|
||||
b.clear();
|
||||
while(num--)
|
||||
{
|
||||
getchar();
|
||||
scanf("%c",&k);
|
||||
if(k=='I')
|
||||
{
|
||||
scanf("%d",&n);
|
||||
ne.m=n;
|
||||
ne.v=n;
|
||||
ne.sum=n;
|
||||
if(a.size()==0)
|
||||
a.push_back(ne);
|
||||
else
|
||||
{
|
||||
int sz=a.size();
|
||||
cur=a[sz-1];
|
||||
ne.sum = cur.sum + ne.v;
|
||||
ne.m = max(ne.sum,cur.m);
|
||||
a.push_back(ne);
|
||||
}
|
||||
}
|
||||
else if(k=='L')
|
||||
{
|
||||
int sz = a.size() ;
|
||||
if(sz)
|
||||
{
|
||||
cur = a[sz-1] ;
|
||||
a.pop_back();
|
||||
b.push_back(cur);
|
||||
}
|
||||
}
|
||||
else if(k=='R')
|
||||
{
|
||||
j = b.size();
|
||||
if(j)
|
||||
{
|
||||
ne=b[j-1];
|
||||
b.pop_back();
|
||||
ne.sum=ne.v;
|
||||
ne.m=ne.v;
|
||||
int sz = a.size();
|
||||
if(sz==0)
|
||||
{
|
||||
ne.sum=ne.v;
|
||||
ne.m=ne.v;
|
||||
a.push_back(ne);
|
||||
}
|
||||
else
|
||||
{
|
||||
cur = a[sz-1];
|
||||
ne.sum = cur.sum + ne.v;
|
||||
ne.m = max(ne.sum,cur.m);
|
||||
a.push_back(ne);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(k=='D')
|
||||
{
|
||||
if(a.size())
|
||||
a.pop_back();
|
||||
}
|
||||
else if(k=='Q')
|
||||
{
|
||||
scanf("%d",&n);
|
||||
printf("%d\n",a[n-1].m);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue