KiritoTRw
GitHub
parent
3845accd4b
commit
ff9985fa25
|
|
@ -0,0 +1,167 @@
|
|||
#include<iostream>
|
||||
#include<stdlib.h>
|
||||
using namespace std;
|
||||
#define N 21
|
||||
int n,sleep,awake;
|
||||
struct Time
|
||||
{
|
||||
int hour;
|
||||
int minite;
|
||||
int sec;
|
||||
void trans()
|
||||
{ sec=hour*60+minite; }
|
||||
void retrans()
|
||||
{ sec+=24*60; }
|
||||
void minusonesecond()
|
||||
{
|
||||
if(minite==0)
|
||||
hour--,minite=59;
|
||||
else minite--;
|
||||
if(hour<0)
|
||||
hour+=24;
|
||||
}
|
||||
void addonesecond()
|
||||
{
|
||||
if(minite==59)
|
||||
hour++,minite=0;
|
||||
else minite++;
|
||||
if(hour>23)
|
||||
hour-=24;
|
||||
}
|
||||
bool operator < (const Time a)const
|
||||
{
|
||||
if(hour==a.hour)
|
||||
{
|
||||
return minite<a.minite;
|
||||
}
|
||||
return hour<a.hour;
|
||||
}
|
||||
};
|
||||
struct Arrange
|
||||
{
|
||||
Time tb,te;
|
||||
} affire[N];
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
struct Arrange *A=(Arrange*)a;
|
||||
struct Arrange *B=(Arrange*)b;
|
||||
if(B->tb<A->tb)
|
||||
return 1;
|
||||
return -1;
|
||||
}
|
||||
Time sle[N][2];
|
||||
char evn[20];
|
||||
void solve(bool flag)
|
||||
{
|
||||
int i,j,begin,end,temp=0,nowlast=0,segn=0;
|
||||
Time temp1,temp2;
|
||||
for(i=2;i<=n;i++)
|
||||
{
|
||||
end=affire[i].tb.sec-1;
|
||||
begin=affire[i-1].te.sec+1;
|
||||
if(end<begin&&begin-end!=1)
|
||||
end+=24*60;
|
||||
if(end-begin+1>=sleep)
|
||||
{
|
||||
++segn;
|
||||
temp1=affire[i-1].te;
|
||||
temp1.addonesecond();
|
||||
sle[segn][0]=temp1;
|
||||
temp1=affire[i].tb;
|
||||
temp1.minusonesecond();
|
||||
sle[segn][1]=temp1;
|
||||
nowlast=0;
|
||||
}
|
||||
else if(end-begin+1<sleep)
|
||||
{
|
||||
if(nowlast==0)
|
||||
nowlast+=affire[i-1].te.sec-affire[i-1].tb.sec+1;
|
||||
nowlast+=affire[i].te.sec-affire[i-1].te.sec+1;
|
||||
if(nowlast>awake)
|
||||
{
|
||||
printf("No\n");
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
end=affire[1].tb.sec-1;
|
||||
begin=affire[n].te.sec+1;
|
||||
if(end<begin&&begin-end!=1)
|
||||
end+=24*60;
|
||||
if(end-begin+1>=sleep)
|
||||
{
|
||||
++segn;
|
||||
temp2=affire[n].te;
|
||||
temp2.addonesecond();
|
||||
sle[segn][0]=temp2;
|
||||
temp1=affire[1].tb;
|
||||
temp1.minusonesecond();
|
||||
sle[segn][1]=temp1;
|
||||
nowlast=0;
|
||||
}
|
||||
else if(end-begin+1<sleep)
|
||||
{
|
||||
if(nowlast==0)
|
||||
nowlast+=affire[n].te.sec-affire[n].tb.sec+1;
|
||||
nowlast+=affire[1].te.sec-affire[n].te.sec+1;
|
||||
if(nowlast>awake)
|
||||
{
|
||||
printf("No\n");
|
||||
return ;
|
||||
}
|
||||
}
|
||||
if(n==0)
|
||||
{
|
||||
segn=1;
|
||||
printf("Yes\n%d\n",segn);
|
||||
printf("00:00-23:59\n");
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(segn!=0)
|
||||
{
|
||||
printf("Yes\n%d\n",segn);
|
||||
for(i=1;i<=segn;i++)
|
||||
{
|
||||
printf("%02d:%02d-%02d:%02d\n",sle[i][0].hour,sle[i][0].minite,sle[i][1].hour,sle[i][1].minite);
|
||||
}
|
||||
}
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&sleep,&awake)!=EOF)
|
||||
{
|
||||
sleep*=60,awake*=60;
|
||||
scanf("%d",&n);
|
||||
int i,j;
|
||||
bool flag=false;
|
||||
bool ss=false;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
Time T1,T2;
|
||||
scanf("%d:%d-%d:%d",&T1.hour,&T1.minite,&T2.hour,&T2.minite);
|
||||
T1.trans(),T2.trans();
|
||||
if(T2.sec-T1.sec+1>awake)
|
||||
{
|
||||
ss=true;
|
||||
}
|
||||
if(T2<T1)
|
||||
{
|
||||
flag=true;
|
||||
T2.retrans();
|
||||
}
|
||||
affire[i].tb=T1,affire[i].te=T2;
|
||||
}
|
||||
if(ss)
|
||||
{
|
||||
printf("No\n");
|
||||
continue;
|
||||
}
|
||||
qsort(affire+1,n,sizeof(Time)*2,cmp);
|
||||
solve(flag);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#define INF 0x7fffffff
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n,A,B;
|
||||
int q[100001],id[100001];
|
||||
while(scanf("%d%d%d",&n,&A,&B)!=EOF)
|
||||
{
|
||||
__int64 Ti=1,s=1;
|
||||
int head=0,tail=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
s=(s*A)%B;
|
||||
while(head<tail && q[tail]>=s) tail--;
|
||||
q[++tail]=s;
|
||||
id[tail]=i;
|
||||
while(id[head+1]<i-A) head++;
|
||||
Ti=(Ti*q[head+1])%B;
|
||||
}
|
||||
printf("%I64d\n",Ti);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int bit[19];
|
||||
__int64 dp[19][19][2005];
|
||||
__int64 dfs(int pos,int o,int l,int work)
|
||||
{
|
||||
if(pos == -1)
|
||||
return l == 0;
|
||||
if(l<0)
|
||||
return 0;
|
||||
if(!work && dp[pos][o][l]!=-1)
|
||||
return dp[pos][o][l];
|
||||
__int64 ans = 0;
|
||||
int end = work?bit[pos]:9;
|
||||
for(int i=0; i<=end; i++)
|
||||
{
|
||||
int next = l;
|
||||
next += (pos-o)*i;
|
||||
ans+=dfs(pos-1,o,next,work&&i==end);
|
||||
}
|
||||
if(!work)
|
||||
dp[pos][o][l] = ans;
|
||||
return ans;
|
||||
}
|
||||
__int64 solve(__int64 n)
|
||||
{
|
||||
int len = 0;
|
||||
while(n)
|
||||
{
|
||||
bit[len++] = n%10;
|
||||
n/=10;
|
||||
}
|
||||
__int64 ans = 0;
|
||||
for(int i = 0; i<len; i++)
|
||||
{
|
||||
ans+=dfs(len-1,i,0,1);
|
||||
}
|
||||
return ans-(len-1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
__int64 l,r;
|
||||
scanf("%d",&T);
|
||||
memset(dp,-1,sizeof(dp));
|
||||
while(T--)
|
||||
{
|
||||
scanf("%I64d%I64d",&l,&r);
|
||||
printf("%I64d\n",solve(r)-solve(l-1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,346 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <ctime>
|
||||
using namespace std;
|
||||
const int N = 20005;
|
||||
const int M = 100005;
|
||||
const int QN = M;
|
||||
const int INF = 0X7FFFFFFF;
|
||||
typedef int vType;
|
||||
typedef pair<int, int> pii;
|
||||
#define mkpii make_pair<int, int>
|
||||
struct e{
|
||||
int v;
|
||||
e* nxt;
|
||||
}es[N<<1], *fir[N];
|
||||
struct node{
|
||||
int ls, rs;
|
||||
int l, r;
|
||||
int id;
|
||||
vType Min;
|
||||
int mid() { return (l + r) >> 1; }
|
||||
}nodes[N<<1];
|
||||
struct se{
|
||||
pii e;
|
||||
int len;
|
||||
}ses[M<<1], lea[M<<1];
|
||||
int n, en, qn, m;
|
||||
vector<pii> qlca[N];
|
||||
vector<se> nes[N];
|
||||
int par[N], fa[N];
|
||||
int ln, cnt;
|
||||
int leaNum;
|
||||
int sons[N], que[N], dep[N], id[N], st[N], ed[N], root[N], top[N], sNum[N];
|
||||
int ith[N], pMin[N], seg[N];
|
||||
vType iw[N];
|
||||
int tr;
|
||||
inline void add_e(int u, int v){
|
||||
es[en].v = v;
|
||||
es[en].nxt = fir[u];
|
||||
fir[u] = &es[en++];
|
||||
}
|
||||
inline void newNode(int& id, int l, int r){
|
||||
nodes[cnt].ls = nodes[cnt].rs = -1;
|
||||
nodes[cnt].l = l;
|
||||
nodes[cnt].r = r;
|
||||
nodes[cnt].Min = INF;
|
||||
id = cnt++;
|
||||
}
|
||||
void build(int& id, int l, int r){
|
||||
newNode(id, l, r);
|
||||
if(l >= r){
|
||||
nodes[id].id = seg[l];
|
||||
return ;
|
||||
}
|
||||
int mid = (l+r)>>1;
|
||||
build(nodes[id].ls, l, mid);
|
||||
build(nodes[id].rs, mid+1, r);
|
||||
}
|
||||
void initTree(){
|
||||
int l, r, u, v, i;
|
||||
e* cur;
|
||||
l = r = 0;
|
||||
que[r++] = tr;
|
||||
par[tr] = -1;
|
||||
dep[tr] = 0;
|
||||
while(l != r){
|
||||
u = que[l++];
|
||||
int g = 1;
|
||||
for(cur = fir[u]; cur; cur = cur->nxt){
|
||||
if((v = cur->v) != par[u]){
|
||||
que[r++] = v;
|
||||
par[v] = u;
|
||||
dep[v] = dep[u]+1;
|
||||
ith[v] = g++;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i = 1; i <= n; i++){
|
||||
sons[i] = 1;
|
||||
sNum[i] = 0;
|
||||
id[i] = -1;
|
||||
}
|
||||
for(i = r-1; i >= 0; i--){
|
||||
u = que[i];
|
||||
if(par[u] >= 0){
|
||||
sons[par[u]] += sons[u];
|
||||
sNum[par[u]]++;
|
||||
}
|
||||
}
|
||||
l = r = 0;
|
||||
que[r++] = tr;
|
||||
ln = cnt = 0;
|
||||
while(l != r){
|
||||
u = que[l++];
|
||||
st[ln] = dep[u];
|
||||
top[ln] = u;
|
||||
while(u >= 0){
|
||||
id[u] = ln;
|
||||
ed[ln] = dep[u];
|
||||
seg[dep[u]] = u;
|
||||
int best;
|
||||
for(cur = fir[u], best=-1; cur; cur = cur->nxt){
|
||||
if(id[v = cur->v] == -1){
|
||||
if(best == -1 || (best >= 0 && sons[v] > sons[best])){
|
||||
best = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(best >= 0){
|
||||
for(cur = fir[u]; cur; cur = cur->nxt){
|
||||
if(id[v = cur->v] == -1 && best != v){
|
||||
que[r++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
u = best;
|
||||
}
|
||||
root[ln] = -1;
|
||||
build(root[ln], st[ln], ed[ln]);
|
||||
ln++;
|
||||
}
|
||||
}
|
||||
int qrylKthFar(int& id, int i, int k){
|
||||
if(nodes[id].l == nodes[id].r) return nodes[id].id;
|
||||
int mid = nodes[id].mid();
|
||||
if(i - mid - 1 >= k) return qrylKthFar(nodes[id].rs, i, k);
|
||||
else return qrylKthFar(nodes[id].ls, i, k);
|
||||
}
|
||||
int qryKthFar(int i, int k){
|
||||
int u = i, ri;
|
||||
while(true){
|
||||
ri = id[u];
|
||||
if(dep[u] - st[ri] >= k){
|
||||
return qrylKthFar(root[ri], dep[u], k);
|
||||
}else{
|
||||
k -= dep[u] - st[ri] + 1;
|
||||
u = par[top[ri]];
|
||||
}
|
||||
}
|
||||
}
|
||||
void inslMin(int& id, int ql, int qr, int mv){
|
||||
if(id == -1) return ;
|
||||
if(ql <= nodes[id].l && nodes[id].r <= qr){
|
||||
if(nodes[id].Min > mv){
|
||||
nodes[id].Min = mv;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(nodes[id].l == nodes[id].r) return;
|
||||
int mid = nodes[id].mid();
|
||||
if(ql <= mid){
|
||||
inslMin(nodes[id].ls, ql, qr, mv);
|
||||
}
|
||||
if(qr > mid){
|
||||
inslMin(nodes[id].rs, ql, qr, mv);
|
||||
}
|
||||
}
|
||||
void insMin(int i, int k, vType mv){
|
||||
int b, u;
|
||||
u = i;
|
||||
while(true){
|
||||
b = id[u];
|
||||
if(dep[u]-st[b] >= k){
|
||||
inslMin(root[b], dep[u]-k, dep[u], mv);
|
||||
return;
|
||||
}else{
|
||||
inslMin(root[b], st[b], dep[u], mv);
|
||||
k -= dep[u] - st[b] + 1;
|
||||
u = par[top[b]];
|
||||
}
|
||||
}
|
||||
}
|
||||
bool input(){
|
||||
scanf("%d%d", &n, &m);
|
||||
int i, k, tn;
|
||||
for(i = tn = 0; i < m; i++){
|
||||
scanf("%d%d%d%d", &ses[i].e.first, &ses[i].e.second, &ses[i].len, &k);
|
||||
if(k == 1){
|
||||
ses[i].len = 0;
|
||||
}
|
||||
if(ses[i].e.first != ses[i].e.second){
|
||||
tn++;
|
||||
}
|
||||
}
|
||||
m = tn;
|
||||
return true;
|
||||
}
|
||||
inline bool cmp(se a, se b){
|
||||
return a.len < b.len;
|
||||
}
|
||||
int findFa(int u){
|
||||
int k = u;
|
||||
while(k != fa[k]) k = fa[k];
|
||||
while(u != k){
|
||||
int tf = fa[u];
|
||||
fa[u] = k;
|
||||
u = tf;
|
||||
}
|
||||
return k;
|
||||
}
|
||||
void merge(int u, int v){
|
||||
int fu, fv;
|
||||
fu = findFa(u);
|
||||
fv = findFa(v);
|
||||
fa[fu] = fv;
|
||||
}
|
||||
int kruskal(int n, int m, int& leaNum, bool flag){
|
||||
int i, ans, k, u, v;
|
||||
for(i = 1; i <= n; i++){
|
||||
fa[i] = i;
|
||||
}
|
||||
if(flag){
|
||||
for(i = 1; i <= n; i++){
|
||||
iw[i] = 0;
|
||||
fir[i] = NULL;
|
||||
}
|
||||
en = leaNum = 0;
|
||||
}
|
||||
sort(ses, ses + m, cmp);
|
||||
for(i = ans = 0, k = 1; k < n && i < m; i++){
|
||||
u = ses[i].e.first;
|
||||
v = ses[i].e.second;
|
||||
if(findFa(u) != findFa(v)){
|
||||
ans += ses[i].len;
|
||||
k++;
|
||||
merge(u, v);
|
||||
if(flag){
|
||||
add_e(u, v);
|
||||
add_e(v, u);
|
||||
iw[u] += ses[i].len;
|
||||
iw[v] += ses[i].len;
|
||||
}
|
||||
}else if(flag){
|
||||
lea[leaNum++] = ses[i];
|
||||
}
|
||||
}
|
||||
if (flag) {
|
||||
for (; i < m; i++) {
|
||||
lea[leaNum++] = ses[i];
|
||||
}
|
||||
}
|
||||
if(k < n) ans = INF;
|
||||
return ans;
|
||||
}
|
||||
void handlelca(int u, int v, int anc, int len){
|
||||
if(u != anc && v != anc){
|
||||
int ku, kv;
|
||||
ku = qryKthFar(u, dep[u] - dep[anc] - 1);
|
||||
kv = qryKthFar(v, dep[v] - dep[anc] - 1);
|
||||
se te;
|
||||
te.e.first = ith[ku];
|
||||
te.e.second = ith[kv];
|
||||
te.len = len;
|
||||
nes[anc].push_back(te);
|
||||
}
|
||||
if(dep[anc] + 2 <= dep[u]){
|
||||
insMin(u, dep[u] - dep[anc] - 2, len);
|
||||
}
|
||||
if(dep[anc] + 2 <= dep[v]){
|
||||
insMin(v, dep[v] - dep[anc] - 2, len);
|
||||
}
|
||||
}
|
||||
int getlca(int u, int v){
|
||||
while(id[u] != id[v]){
|
||||
if(id[u] < id[v]) swap(u, v);
|
||||
u = par[top[id[u]]];
|
||||
}
|
||||
if(dep[u] < dep[v]) swap(u, v);
|
||||
return v;
|
||||
}
|
||||
void lca(se* qs, int qn){
|
||||
int i;
|
||||
for(i = 1; i <= n; i++){
|
||||
nes[i].clear();
|
||||
}
|
||||
for(i = 0; i < qn; i++){
|
||||
int u, v, anc;
|
||||
u = qs[i].e.first;
|
||||
v = qs[i].e.second;
|
||||
anc = getlca(u, v);
|
||||
handlelca(v, u, anc, qs[i].len);
|
||||
}
|
||||
}
|
||||
void getpMin(int& id, int mv){
|
||||
if(mv > nodes[id].Min){
|
||||
mv = nodes[id].Min;
|
||||
}
|
||||
if(nodes[id].l == nodes[id].r){
|
||||
pMin[nodes[id].id] = mv;
|
||||
return;
|
||||
}
|
||||
getpMin(nodes[id].ls, mv);
|
||||
getpMin(nodes[id].rs, mv);
|
||||
}
|
||||
void getpMin(){
|
||||
int i;
|
||||
for(i = 0; i < ln; i++){
|
||||
getpMin(root[i], INF);
|
||||
}
|
||||
}
|
||||
void solve(){
|
||||
tr = 1;
|
||||
int sum, i, sn, v, num;
|
||||
e* cur;
|
||||
sum = kruskal(n, m, leaNum, true);
|
||||
initTree();
|
||||
lca(lea, leaNum);
|
||||
getpMin();
|
||||
for(i = 1; i <= n; i++){
|
||||
num = 0;
|
||||
sn = sNum[i];
|
||||
if (par[i] >= 1) {
|
||||
sn++;
|
||||
for (cur = fir[i]; cur; cur = cur->nxt) {
|
||||
if ((v = cur->v) != par[i] && pMin[v] < INF) {
|
||||
ses[num].e.first = sn;
|
||||
ses[num].e.second = ith[v];
|
||||
ses[num].len = pMin[v];
|
||||
num++;
|
||||
}
|
||||
}
|
||||
}
|
||||
int size = nes[i].size(), j;
|
||||
for(j = 0; j < size; j++){
|
||||
ses[num++] = nes[i][j];
|
||||
}
|
||||
int ans = kruskal(sn, num, leaNum, false);
|
||||
if(ans < INF){
|
||||
ans += sum - iw[i];
|
||||
printf("%d\n", ans);
|
||||
}else{
|
||||
printf("inf\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t--){
|
||||
input();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 101;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
int n, m;
|
||||
int a[maxn];
|
||||
int cal(int a, int b)
|
||||
{
|
||||
int M = a ^ b;
|
||||
int num = 0;
|
||||
while(M)
|
||||
{
|
||||
M &= (M-1);
|
||||
num++;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
int get_ans(int t)
|
||||
{
|
||||
int min = INF, num = 0, ans;
|
||||
for(int i = 0; i < n; i++)
|
||||
{
|
||||
num = cal(a[i], t);
|
||||
if(num < min) { min = num; ans = a[i]; }
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
void read_case()
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(int i = 0; i < n; i++) scanf("%d", &a[i]);
|
||||
sort(a, a+n);
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
read_case();
|
||||
int t;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d", &t);
|
||||
int ans = get_ans(t);
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
#include<cstdio>
|
||||
#include<iostream>
|
||||
#include<complex>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
#define Y imag
|
||||
#define X real
|
||||
const double eps = 1e-9;
|
||||
const char *err = "Error";
|
||||
const double pi = acos(-1.0);
|
||||
typedef complex<double> pnt;
|
||||
static double dot(const pnt &a, const pnt& b) {return X(conj(a)*b);}
|
||||
static double cross(const pnt &a, const pnt &b) {return imag(conj(a)*b);}
|
||||
void work(const pnt& s, double argu) {
|
||||
while(argu<0) argu+=2*pi;
|
||||
while(argu >= 2*pi) argu -=2*pi;
|
||||
if(argu < pi+eps) {
|
||||
puts(err);
|
||||
return ;
|
||||
}
|
||||
argu = - argu;
|
||||
printf("%.3lf\n", X(s) +( abs(argu + 3*pi/2)<eps ? 0 : Y(s)/tan(argu) ));
|
||||
}
|
||||
pnt jdg(const pnt& p0, const pnt& p1,const pnt& p3, const pnt& p2){
|
||||
if(cross(p3-p0,p1-p0) * cross(p2-p0,p1-p0) > -eps) return p0;
|
||||
double s1 = cross(p2-p1,p0-p1), s2 = cross(p3-p1,p0-p1);
|
||||
s1 = abs(s1), s2 = abs(s2);
|
||||
double x = (X(p2) *s2 + X(p3)*s1) / (s1+ s2);
|
||||
double y = (Y(p2) *s2 + Y(p3)*s1) / (s1+ s2);
|
||||
pnt p(x,y);
|
||||
if(cross(p3-p2,p1-p2)*cross(p3-p2,p0-p2)>0 && abs(p-p0) < abs(p-p1)) return p0;
|
||||
return p;
|
||||
}
|
||||
double cal(double arg0, double arg1, double tmp) {
|
||||
double t1 =arg1+pi/2-(arg0+pi);
|
||||
double s1 = sin(t1);
|
||||
double s2 = s1/tmp;
|
||||
if(s2>=1.0 || s2 <=-1.0) return 1e10;
|
||||
else return arg1-pi/2-asin(s2);
|
||||
}
|
||||
int main(){
|
||||
int tst;
|
||||
double tmp;
|
||||
cin >> tst;
|
||||
pnt p[3];
|
||||
while(tst--) {
|
||||
double x1,y1,x2,y2;
|
||||
while(cin >> x1 >> y1 >> x2 >> y2){
|
||||
pnt p1(x1,y1), p2(x2,y2), p0;
|
||||
int s = -1;
|
||||
double mx = 1e10;
|
||||
for(int i=0;i<3;i++){
|
||||
cin >> x1 >> y1;
|
||||
p[i] = pnt(x1,y1);
|
||||
}
|
||||
cin >> tmp;
|
||||
for(int i=0;i<3;i++) {
|
||||
pnt P = jdg(p1,p2,p[i],p[(i+1)%3]);
|
||||
if(P == p1) continue;
|
||||
double v = abs(p1-P);
|
||||
if(v < mx) mx = v, s = i, p0 = P;
|
||||
}
|
||||
if(s == -1){
|
||||
work(p1, arg(p2-p1));
|
||||
continue;
|
||||
}
|
||||
pnt p3;
|
||||
double t = 0;
|
||||
if(cross(p2-p1, p[(s+1)%3] - p[s])<0)t = pi;
|
||||
double arg0 = cal(arg(p2-p1),arg(p[(s+1)%3] - p[s])+t,tmp);
|
||||
pnt np = pnt(X(p0) + 200*cos(arg0), Y(p0) + 200*sin(arg0));
|
||||
int k = -1;
|
||||
for(int i=0;i<3;i++) {
|
||||
if(i==s) continue;
|
||||
pnt P = jdg(p0,np,p[i],p[(i+1)%3]);
|
||||
if(P == p0) continue;
|
||||
k = i;p3 = P;
|
||||
}
|
||||
t = 0;
|
||||
if(cross(p3-p0, p[(k+1)%3] - p[k])<0)t = pi;
|
||||
double arg1 = cal(arg(p3 - p0), arg(p[(k+1)%3] - p[k])+t, 1.0/tmp);
|
||||
if(arg1 == 1e10) {
|
||||
puts(err);
|
||||
continue;
|
||||
}
|
||||
work(p3,arg1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
typedef pair<pair<int, int>, pair<int, int> > Node;
|
||||
const int MAXN = 8;
|
||||
int T, mat[2][MAXN][MAXN];
|
||||
char stepto[MAXN][MAXN][MAXN][MAXN], mo[] = {'D','L','R','U'};
|
||||
Node s, t, fa[MAXN][MAXN][MAXN][MAXN];
|
||||
queue<Node> Q;
|
||||
void ReadMat()
|
||||
{
|
||||
for (int i = 1; i <= 6; i++)
|
||||
for (int j = 1; j <= 6; j++)
|
||||
{
|
||||
scanf("%d", &mat[1][i][j]);
|
||||
if (mat[1][i][j]&(1<<5))
|
||||
s.second = make_pair(i, j);
|
||||
if (mat[1][i][j]&(1<<6))
|
||||
t.second = make_pair(i, j);
|
||||
}
|
||||
}
|
||||
void PrintAns(Node v)
|
||||
{
|
||||
if (stepto[v.first.first][v.first.second][v.second.first][v.second.second] == 'X')
|
||||
return;
|
||||
PrintAns(fa[v.first.first][v.first.second][v.second.first][v.second.second]);
|
||||
printf("%c", stepto[v.first.first][v.first.second][v.second.first][v.second.second]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &T);
|
||||
ReadMat();
|
||||
while (--T)
|
||||
{
|
||||
memset(stepto, 0, sizeof(stepto));
|
||||
memcpy(mat[0], mat[1], MAXN*MAXN*sizeof(int));
|
||||
s.first = s.second;
|
||||
t.first = t.second;
|
||||
ReadMat();
|
||||
while (!Q.empty()) Q.pop();
|
||||
bool flag = 0;
|
||||
Q.push(s);
|
||||
stepto[s.first.first][s.first.second][s.second.first][s.second.second] = 'X';
|
||||
while (!Q.empty())
|
||||
{
|
||||
Node u = Q.front(); Q.pop();
|
||||
if (u == t)
|
||||
{
|
||||
flag = 1;
|
||||
break;
|
||||
}
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
Node v = u;
|
||||
if (i == 0)
|
||||
{
|
||||
if (!(mat[0][u.first.first][u.first.second]&(1<<1)))
|
||||
v.first.first++;
|
||||
if (!(mat[1][u.second.first][u.second.second]&(1<<1)))
|
||||
v.second.first++;
|
||||
}
|
||||
else if (i == 1)
|
||||
{
|
||||
if (!(mat[0][u.first.first][u.first.second]&(1<<0)))
|
||||
v.first.second--;
|
||||
if (!(mat[1][u.second.first][u.second.second]&(1<<0)))
|
||||
v.second.second--;
|
||||
}
|
||||
else if (i == 2)
|
||||
{
|
||||
if (!(mat[0][u.first.first][u.first.second]&(1<<2)))
|
||||
v.first.second++;
|
||||
if (!(mat[1][u.second.first][u.second.second]&(1<<2)))
|
||||
v.second.second++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!(mat[0][u.first.first][u.first.second]&(1<<3)))
|
||||
v.first.first--;
|
||||
if (!(mat[1][u.second.first][u.second.second]&(1<<3)))
|
||||
v.second.first--;
|
||||
}
|
||||
if (v.first.first < 1 || v.first.first > 6)
|
||||
continue;
|
||||
if (v.first.second < 1 || v.first.second > 6)
|
||||
continue;
|
||||
if (v.second.first < 1 || v.second.first > 6)
|
||||
continue;
|
||||
if (v.second.second < 1 || v.second.second > 6)
|
||||
continue;
|
||||
if (!(mat[0][v.first.first][v.first.second]&(1<<4)) || !(mat[1][v.second.first][v.second.second]&(1<<4)))
|
||||
continue;
|
||||
if (!stepto[v.first.first][v.first.second][v.second.first][v.second.second])
|
||||
{
|
||||
Q.push(v);
|
||||
stepto[v.first.first][v.first.second][v.second.first][v.second.second] = mo[i];
|
||||
fa[v.first.first][v.first.second][v.second.first][v.second.second] = u;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag)
|
||||
PrintAns(t);
|
||||
else
|
||||
printf("-1");
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include"stdio.h"
|
||||
#include"string.h"
|
||||
#include"stdlib.h"
|
||||
#include"math.h"
|
||||
#define e 1e-9
|
||||
int n;
|
||||
int a[10011],b[10011],c[10011];
|
||||
double MAX(double q,double p)
|
||||
{
|
||||
return q>p?q:p;
|
||||
}
|
||||
double cal(double x)
|
||||
{
|
||||
int i;
|
||||
double max=-111111111;
|
||||
for(i=0;i<n;i++) max=MAX(max,a[i]*x*x+b[i]*x+c[i]);
|
||||
return max;
|
||||
}
|
||||
double solve()
|
||||
{
|
||||
double left,right,mid,midmid;
|
||||
double mid_cal,midmid_cal;
|
||||
left=0;
|
||||
right=1000;
|
||||
while(right-left>e)
|
||||
{
|
||||
mid=(left+right)/2;
|
||||
midmid=(mid+right)/2;
|
||||
mid_cal=cal(mid);
|
||||
midmid_cal=cal(midmid);
|
||||
if(mid_cal>midmid_cal) left=mid;
|
||||
else right=midmid;
|
||||
}
|
||||
return cal(right);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int i;
|
||||
double ans;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++) scanf("%d%d%d",&a[i],&b[i],&c[i]);
|
||||
ans=solve();
|
||||
printf("%.4lf\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
using namespace std;
|
||||
#define print(x) cout<<x<<endl
|
||||
#define input(x) cin>>x
|
||||
#define N 512
|
||||
#define M 40000
|
||||
#define SIZE 10240
|
||||
struct node
|
||||
{
|
||||
int val,next;
|
||||
node(){}
|
||||
node(int ival,int inext)
|
||||
{
|
||||
val=ival;next=inext;
|
||||
}
|
||||
};
|
||||
int n,m;
|
||||
int a[SIZE],b[SIZE],c[SIZE];
|
||||
int head[SIZE];
|
||||
node g[M];
|
||||
int ind;
|
||||
char instack[SIZE];
|
||||
stack<int> st;
|
||||
int dfn[SIZE],scc[SIZE],num[SIZE],low[SIZE];
|
||||
int sccnr,nr;
|
||||
void init()
|
||||
{
|
||||
ind=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(instack,0,sizeof(instack));
|
||||
memset(scc,0,sizeof(scc));
|
||||
memset(num,0,sizeof(num));
|
||||
memset(low,0,sizeof(low));
|
||||
memset(dfn,0,sizeof(dfn));
|
||||
st=stack<int>();
|
||||
nr=1;sccnr=0;
|
||||
}
|
||||
void tarjan(int pos)
|
||||
{
|
||||
low[pos]=dfn[pos]=nr++;
|
||||
st.push(pos);
|
||||
instack[pos]=1;
|
||||
for(int i=head[pos];i!=-1;i=g[i].next)
|
||||
{
|
||||
int j=g[i].val;
|
||||
if(!dfn[j])
|
||||
{
|
||||
tarjan(j);
|
||||
low[pos]=min(low[pos],low[j]);
|
||||
}
|
||||
else if(instack[j])
|
||||
{
|
||||
low[pos]=min(low[pos],dfn[j]);
|
||||
}
|
||||
}
|
||||
if(dfn[pos]==low[pos])
|
||||
{
|
||||
sccnr++;
|
||||
while(1)
|
||||
{
|
||||
int t=st.top();
|
||||
instack[t]=0;
|
||||
st.pop();
|
||||
scc[t]=sccnr;
|
||||
num[sccnr]++;
|
||||
if(t==pos) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
bool zSat()
|
||||
{
|
||||
for(int i=0;i<n*2;i++)
|
||||
{
|
||||
if(!dfn[i]) tarjan(i);
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
if(scc[i]==scc[i+n])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void addEdge(int a,int b)
|
||||
{
|
||||
g[ind]=node(b,head[a]);
|
||||
head[a]=ind++;
|
||||
}
|
||||
void makeG(int x)
|
||||
{
|
||||
init();
|
||||
for(int i=0;i<x;i++)
|
||||
{
|
||||
int p=a[i],q=b[i];
|
||||
if(c[i]==0)
|
||||
{
|
||||
addEdge(p,q+n);
|
||||
addEdge(q,p+n);
|
||||
}
|
||||
else if(c[i]==1)
|
||||
{
|
||||
addEdge(p,q);
|
||||
addEdge(q,p);
|
||||
addEdge(p+n,q+n);
|
||||
addEdge(q+n,p+n);
|
||||
}
|
||||
else if(c[i]==2)
|
||||
{
|
||||
addEdge(p+n,q);
|
||||
addEdge(q+n,p);
|
||||
}
|
||||
}
|
||||
}
|
||||
int slove()
|
||||
{
|
||||
int l=0,r=m;
|
||||
while(l<=r)
|
||||
{
|
||||
int mid=(l+r)>>1;
|
||||
makeG(mid);
|
||||
if(zSat()) l=mid+1;
|
||||
else r=mid-1;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
input(T);
|
||||
while(T--)
|
||||
{
|
||||
input(n>>m);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d%d%d",a+i,b+i,c+i);
|
||||
}
|
||||
print(slove());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#include <climits>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <list>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <deque>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
const int maxa = 20;
|
||||
const int maxc = 40;
|
||||
const int maxn = 60;
|
||||
double dp[2][maxn][3][maxa][maxc];
|
||||
double b[2][3], d[2][3];
|
||||
inline double P(int i, int j, int n)
|
||||
{
|
||||
return max(0.0, min(1.0, b[i][j] - n * d[i][j]));
|
||||
}
|
||||
double f(int id, int n, int m, int a, int c)
|
||||
{
|
||||
double &ret = dp[id][n][m][a][c];
|
||||
if (ret >= 0) return ret;
|
||||
if (a == 0 && c == 0) return ret = 0;
|
||||
int n0 = n, a0 = a;
|
||||
if (m == 0) n++;
|
||||
if (m == 2) a++;
|
||||
m = (m + 1) % 3;
|
||||
ret = 0;
|
||||
if (a0 > 0)
|
||||
{
|
||||
ret = max(ret, P(id, 0, n0) * (1.0 - f(1-id, n, m, a-1, c)));
|
||||
ret = max(ret, P(id, 1, n0) * (1.0 - f(1-id, n, m, a-1, c+1)));
|
||||
}
|
||||
if (c > 0)
|
||||
{
|
||||
ret = max(ret, P(id, 2, n0) * (1.0 - f(1-id, n, m, a, c-1)));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T, n;
|
||||
scanf("%d", &T);
|
||||
while (T--)
|
||||
{
|
||||
for (int i=0;i<2;i++)
|
||||
for (int n=0;n<maxn;n++)
|
||||
for (int m=0;m<3;m++)
|
||||
for (int a=0;a<maxa;a++)
|
||||
for (int c=0;c<maxc;c++)
|
||||
dp[i][n][m][a][c] = -1;
|
||||
scanf("%d", &n);
|
||||
for (int i=0;i<2;i++)
|
||||
for (int j=0;j<3;j++)
|
||||
scanf("%lf%lf", &b[i][j], &d[i][j]);
|
||||
printf("%.4lf\n", f(0, n, 0, n-1, 0));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<iostream>
|
||||
#define maxn 50005
|
||||
#define ll long long
|
||||
using namespace std;
|
||||
ll cnt[maxn];
|
||||
ll num[maxn];
|
||||
int n,k,t;
|
||||
bool check(ll x)
|
||||
{
|
||||
ll sum_2=0,sum_1=0,sum=0,ans=0;
|
||||
int j=n-1;
|
||||
for(int i=n-1;i>=0;i--)
|
||||
{
|
||||
if(j>i)
|
||||
{
|
||||
while((j-i)*(j-i)>=x)
|
||||
{
|
||||
sum_2-=cnt[j]*(j-i-1)*(j-i-1);
|
||||
sum_1-=cnt[j]*(j-i-1);
|
||||
sum-=cnt[j];
|
||||
j--;
|
||||
}
|
||||
}
|
||||
sum_2+=2*sum_1+sum;
|
||||
sum_1+=sum;
|
||||
ll y=num[i]-sum*x+sum_2;
|
||||
if(y<0)cnt[i]=0;
|
||||
else cnt[i]=y/x+1;
|
||||
sum+=cnt[i];
|
||||
ans+=cnt[i];
|
||||
}
|
||||
return ans<=k;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
cin>>n>>k;
|
||||
for(int i=0;i<n;i++)cin>>num[i];
|
||||
ll l=1,r=1e12;
|
||||
while(l<r)
|
||||
{
|
||||
ll mid=(l+r)>>1;
|
||||
if(check(mid))r=mid;
|
||||
else l=mid+1;
|
||||
}
|
||||
cout<<l<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,138 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#define size 10001
|
||||
#define _clr(x) memset(x,0xff,sizeof(int)*26)
|
||||
#define inf 1000000000
|
||||
using namespace std;
|
||||
int g[26][26];
|
||||
bool l[26][size];
|
||||
int KM(int n);
|
||||
bool HaveLetter[26];
|
||||
struct loc
|
||||
{
|
||||
int a[size];
|
||||
int len;
|
||||
loc(){len = 0;}
|
||||
void add(int val)
|
||||
{
|
||||
a[len++] = val;
|
||||
}
|
||||
}locate1[26],locate2[26],rem2,rem1;
|
||||
void InitGraph(int n)
|
||||
{
|
||||
int i,j,A;
|
||||
memset(HaveLetter,0,sizeof(HaveLetter));
|
||||
for(i=0;i<26;i++)
|
||||
locate2[i].len = 0;
|
||||
for (i=0;i<n;i++)
|
||||
{
|
||||
for (j=0;j<n;j++)
|
||||
{
|
||||
g[i][j] = 0;
|
||||
}
|
||||
}
|
||||
for (i=0;i<rem2.len;i++)
|
||||
{
|
||||
A = rem2.a[i];
|
||||
memset(l[A],0,sizeof(l[A]));
|
||||
}
|
||||
}
|
||||
void GreateGraph()
|
||||
{
|
||||
int i,j,k,A,B,locate;
|
||||
int count[26];
|
||||
for (i=0;i<rem1.len;i++)
|
||||
{
|
||||
A = rem1.a[i];
|
||||
memset(count,0,sizeof(count));
|
||||
for (j=0;j<locate1[A].len;j++)
|
||||
{
|
||||
locate = locate1[A].a[j];
|
||||
for (k=0;k<rem2.len;k++)
|
||||
{
|
||||
B = rem2.a[k];
|
||||
if(l[B][locate])
|
||||
{
|
||||
count[B]++;
|
||||
g[i][k] = count[B];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T,n,k,m,i,letter;
|
||||
char ch[2];
|
||||
scanf("%d",&T);
|
||||
while (T--)
|
||||
{
|
||||
scanf("%d%d%d",&n,&k,&m);
|
||||
memset(HaveLetter,0,sizeof(HaveLetter));
|
||||
rem1.len = 0;
|
||||
for(i=0;i<26;i++)
|
||||
locate1[i].len = 0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",ch);
|
||||
letter = ch[0]-'A';
|
||||
if(!HaveLetter[letter])
|
||||
rem1.add(letter),HaveLetter[letter] = 1;
|
||||
locate1[letter].add(i);
|
||||
}
|
||||
sort(rem1.a,rem1.a+rem1.len);
|
||||
while (m--)
|
||||
{
|
||||
InitGraph(k);
|
||||
rem2.len=0;
|
||||
for (i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",ch);
|
||||
letter = ch[0]-'A';
|
||||
if(!HaveLetter[letter])
|
||||
rem2.add(letter),HaveLetter[letter] = 1;
|
||||
locate2[letter].add(i);
|
||||
l[letter][i] = 1;
|
||||
}
|
||||
sort(rem2.a,rem2.a+rem2.len);
|
||||
GreateGraph();
|
||||
printf("%.4lf\n",KM(k)*1.0/n);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int KM(int n)
|
||||
{
|
||||
int s[26],t[26],l1[26],l2[26],p,q,ret=0,i,j,k;
|
||||
int match1[26],match2[26];
|
||||
for (i=0;i<n;i++)
|
||||
for (l1[i]=-inf,j=0;j<n;j++)
|
||||
l1[i]=g[i][j]>l1[i]?g[i][j]:l1[i];
|
||||
for (i=0;i<n;l2[i++]=0);
|
||||
for (_clr(match1),_clr(match2),i=0;i<n;i++)
|
||||
{
|
||||
for (_clr(t),s[p=q=0]=i;p<=q&&match1[i]<0;p++)
|
||||
for (k=s[p],j=0;j<n&&match1[i]<0;j++)
|
||||
if (l1[k]+l2[j]==g[k][j]&&t[j]<0)
|
||||
{
|
||||
s[++q]=match2[j],t[j]=k;
|
||||
if (s[q]<0)
|
||||
for (p=j;p>=0;j=p)
|
||||
match2[j]=k=t[j],p=match1[k],match1[k]=j;
|
||||
}
|
||||
if (match1[i]<0)
|
||||
{
|
||||
for (i--,p=inf,k=0;k<=q;k++)
|
||||
for (j=0;j<n;j++)
|
||||
if (t[j]<0&&l1[s[k]]+l2[j]-g[s[k]][j]<p)
|
||||
p=l1[s[k]]+l2[j]-g[s[k]][j];
|
||||
for (j=0;j<n;l2[j]+=t[j]<0?0:p,j++);
|
||||
for (k=0;k<=q;l1[s[k++]]-=p);
|
||||
}
|
||||
}
|
||||
for (i=0;i<n;i++)
|
||||
ret+=g[i][match1[i]];
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -0,0 +1,267 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
struct Snooker{
|
||||
char name[2][30];
|
||||
int score[2];
|
||||
int ball_cnt[10];
|
||||
int red_cnt;
|
||||
int turn;
|
||||
int next;
|
||||
bool over;
|
||||
bool foul[5];
|
||||
int penalty;
|
||||
int ball_first;
|
||||
bool replaced[10];
|
||||
bool first;
|
||||
bool second;
|
||||
bool last;
|
||||
char stroke[2000];
|
||||
char ball_name[10];
|
||||
}game;
|
||||
void init1()
|
||||
{
|
||||
int i;
|
||||
game.score[0] = game.score[1] = 0;
|
||||
game.ball_cnt[1] = 15;
|
||||
for(i=2;i<=7;i++)
|
||||
game.ball_cnt[i] = 1;
|
||||
game.turn = 0;
|
||||
game.next = 1;
|
||||
game.last = false;
|
||||
game.over = false;
|
||||
}
|
||||
void init2()
|
||||
{
|
||||
game.red_cnt = 0;
|
||||
memset(game.foul,false,sizeof(game.foul));
|
||||
game.penalty = 4;
|
||||
game.ball_first = -1;
|
||||
memset(game.replaced,false,sizeof(game.replaced));
|
||||
game.first = game.second = false;
|
||||
}
|
||||
int gao1()
|
||||
{
|
||||
char ch[][10] = {"None","Red","Yellow","Green","Brown","Blue","Pink","Black","White"};
|
||||
for(int i=0;i<9;i++)
|
||||
if(strcmp(game.ball_name,ch[i])==0)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
void gao2()
|
||||
{
|
||||
int state = gao1();
|
||||
if(state==0)
|
||||
game.foul[0] = true;
|
||||
else
|
||||
{
|
||||
if(game.next == 1 && state > 1)
|
||||
game.foul[1] = true;
|
||||
else if(game.next > 1 && state == 1)
|
||||
game.foul[1] = true;
|
||||
else if(game.next <= 7 && game.next != state)
|
||||
game.foul[1] = true;
|
||||
}
|
||||
game.first = true;
|
||||
game.ball_first = state;
|
||||
}
|
||||
void gao3()
|
||||
{
|
||||
if(game.second)
|
||||
{
|
||||
int state = gao1();
|
||||
if(game.ball_first != state)
|
||||
game.foul[2] = true;
|
||||
if(state > 7)
|
||||
game.foul[3] = true;
|
||||
if(state == 1)
|
||||
game.red_cnt++;
|
||||
game.replaced[state] = true;
|
||||
}
|
||||
}
|
||||
void gao4()
|
||||
{
|
||||
int i;
|
||||
if(game.last)
|
||||
{
|
||||
if(game.foul[0] || game.foul[1] || game.foul[2] || game.foul[3])
|
||||
{
|
||||
printf("Foul!\n");
|
||||
game.score[game.turn^1] += 7;
|
||||
}
|
||||
else if(game.second)
|
||||
game.score[game.turn] += 7;
|
||||
game.turn^=1;
|
||||
printf("%d : %d\n",game.score[0],game.score[1]);
|
||||
if(game.foul[0] || game.foul[1] || game.foul[2] || game.foul[3] || game.second)
|
||||
{
|
||||
if(game.score[0] == game.score[1])
|
||||
{
|
||||
printf("Tie\nRespot Black\n");
|
||||
game.next = 7;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(game.score[0] > game.score[1])
|
||||
printf("%s wins\n",game.name[0]);
|
||||
else
|
||||
printf("%s wins\n",game.name[1]);
|
||||
game.over = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
printf("%s's turn\n",game.name[game.turn]);
|
||||
return;
|
||||
}
|
||||
game.ball_cnt[1] -= game.red_cnt;
|
||||
if(game.foul[0] || game.foul[1] || game.foul[2] || game.foul[3])
|
||||
{
|
||||
printf("Foul!\n");
|
||||
game.turn^=1;
|
||||
game.score[game.turn] += game.penalty;
|
||||
printf("%d : %d\n",game.score[0],game.score[1]);
|
||||
if(game.replaced[2] || game.replaced[3] || game.replaced[4] || game.replaced[5] || game.replaced[6] || game.replaced[7])
|
||||
{
|
||||
char ch[][10] = {"","","Yellow","Green","Brown","Blue","Pink","Black"};
|
||||
printf("Respot");
|
||||
for(i=2;i<=7;i++)
|
||||
{
|
||||
if(game.replaced[i])
|
||||
printf(" %s",ch[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
for(i=1;i<=7;i++)
|
||||
{
|
||||
if(game.ball_cnt[i] > 0)
|
||||
{
|
||||
game.next = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!game.foul[3])
|
||||
printf("%s's turn\n",game.name[game.turn]);
|
||||
else
|
||||
printf("%s's turn, in-hand\n",game.name[game.turn]);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(game.next == 1)
|
||||
game.score[game.turn] += game.red_cnt;
|
||||
else if(game.second)
|
||||
game.score[game.turn] += game.ball_first;
|
||||
printf("%d : %d\n",game.score[0],game.score[1]);
|
||||
if(game.next == 8 && game.second)
|
||||
{
|
||||
char ch[][10] = {"","","Yellow","Green","Brown","Blue","Pink","Black"};
|
||||
printf("Respot");
|
||||
for(i=2;i<=7;i++)
|
||||
{
|
||||
if(game.replaced[i])
|
||||
printf(" %s",ch[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
if(game.next > 1 && game.second)
|
||||
{
|
||||
game.ball_cnt[game.next]--;
|
||||
if(game.ball_cnt[6] == 0)
|
||||
game.last = true;
|
||||
}
|
||||
}
|
||||
if(game.red_cnt > 0)
|
||||
game.next = 8;
|
||||
else
|
||||
{
|
||||
for(i=1;i<=7;i++)
|
||||
{
|
||||
if(game.ball_cnt[i] > 0)
|
||||
{
|
||||
game.next = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!game.second)
|
||||
{
|
||||
game.turn^=1;
|
||||
printf("%s's turn\n",game.name[game.turn]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int Max(int a,int b)
|
||||
{
|
||||
if(a > b)
|
||||
return a;
|
||||
return b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,ca,len,i,fi;
|
||||
scanf("%d",&t);
|
||||
for(ca=1;ca<=t;ca++)
|
||||
{
|
||||
if(ca>1)
|
||||
printf("\n");
|
||||
printf("Frame %d\n",ca);
|
||||
init1();
|
||||
scanf(" %s %s",game.name[0],game.name[1]);
|
||||
getchar();
|
||||
printf("%s's turn, in-hand\n",game.name[game.turn]);
|
||||
while(!game.over)
|
||||
{
|
||||
gets(game.stroke);
|
||||
if(strcmp(game.stroke,"Play again")==0)
|
||||
{
|
||||
game.turn^=1;
|
||||
if(!game.foul[3])
|
||||
printf("%s's turn\n",game.name[game.turn]);
|
||||
else
|
||||
printf("%s's turn, in-hand\n",game.name[game.turn]);
|
||||
continue;
|
||||
}
|
||||
if(strcmp(game.stroke,game.name[0])==0)
|
||||
{
|
||||
game.turn=0;
|
||||
printf("%s's turn, in-hand\n",game.name[game.turn]);
|
||||
continue;
|
||||
}
|
||||
if(strcmp(game.stroke,game.name[1])==0)
|
||||
{
|
||||
game.turn=1;
|
||||
printf("%s's turn, in-hand\n",game.name[game.turn]);
|
||||
continue;
|
||||
}
|
||||
len = strlen(game.stroke);
|
||||
init2();
|
||||
for(i=fi=0;i<len;i++)
|
||||
{
|
||||
if(game.stroke[i] == ' ' || i + 1 == len)
|
||||
{
|
||||
if(fi == 0)
|
||||
continue;
|
||||
if(i + 1 == len)
|
||||
game.ball_name[fi++] = game.stroke[i];
|
||||
if(gao1()<8)
|
||||
game.penalty = Max(game.penalty,gao1());
|
||||
if(!game.first)
|
||||
gao2();
|
||||
else
|
||||
game.second = true;
|
||||
gao3();
|
||||
fi = 0;
|
||||
memset(game.ball_name,'\0',sizeof(game.ball_name));
|
||||
}
|
||||
else
|
||||
{
|
||||
game.ball_name[fi++] = game.stroke[i];
|
||||
}
|
||||
}
|
||||
if(game.next<8)
|
||||
game.penalty = Max(game.penalty,game.next);
|
||||
gao4();
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
#define inf 100000000
|
||||
char s[35],ps[35];
|
||||
map<string,int> mp;
|
||||
const int limit[5]={0,1,4,4,2};
|
||||
int v[25],g[25][25],id[25],cnt[5],t[12],ans;
|
||||
int gao(char x[])
|
||||
{
|
||||
if (x[0]=='g') return 1;
|
||||
if (x[0]=='d') return 2;
|
||||
if (x[0]=='m') return 3;
|
||||
return 4;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int m,x;
|
||||
mp.clear();
|
||||
memset(g,0,sizeof(g));
|
||||
for (int i=1;i<=23;++i)
|
||||
{
|
||||
mp[s]=i;
|
||||
id[i]=gao(ps);
|
||||
if (i<23) scanf("%s%d%s",s,&v[i+1],ps);
|
||||
}
|
||||
scanf("%d",&m);
|
||||
for (int i=1;i<=m;++i)
|
||||
{
|
||||
scanf("%s%s%d",s,ps,&x);
|
||||
g[mp[s]][mp[ps]]=x;
|
||||
g[mp[ps]][mp[s]]=x;
|
||||
}
|
||||
}
|
||||
void updata()
|
||||
{
|
||||
int temp=0;
|
||||
for (int i=1;i<=11;++i)
|
||||
temp+=v[t[i]];
|
||||
for (int i=1;i<=11;++i)
|
||||
for (int j=i+1;j<=11;++j)
|
||||
temp+=g[t[i]][t[j]];
|
||||
if (temp>ans) ans=temp;
|
||||
}
|
||||
void dfs(int x,int y)
|
||||
{
|
||||
if (y==11)
|
||||
{
|
||||
updata();
|
||||
return;
|
||||
}
|
||||
if (x>23) return;
|
||||
for (int i=0;i<=1;++i)
|
||||
{
|
||||
cnt[id[x]]+=i;
|
||||
if (cnt[id[x]]<=limit[id[x]])
|
||||
{ if (i) t[y+1]=x;
|
||||
dfs(x+1,y+i);
|
||||
}
|
||||
cnt[id[x]]-=i;
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
memset(cnt,0,sizeof(cnt));
|
||||
ans=-inf;
|
||||
dfs(1,0);
|
||||
if (ans==-inf) printf("impossible\n");
|
||||
else printf("%d\n",ans);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (scanf("%s%d%s",s,&v[1],ps)!=EOF)
|
||||
{
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
using namespace std;
|
||||
const int maxn = 2505;
|
||||
struct Graph {
|
||||
int hed[maxn], pnt[maxn*2], val[maxn*2], nxt[maxn*2], cnt;
|
||||
void init(int n) {
|
||||
cnt = 0;
|
||||
memset(hed, -1, 4 * n);
|
||||
}
|
||||
void addedge(int x, int y, int v) {
|
||||
pnt[cnt] = y; val[cnt] = v; nxt[cnt] = hed[x]; hed[x] = cnt++;
|
||||
pnt[cnt] = x; val[cnt] = v; nxt[cnt] = hed[y]; hed[y] = cnt++;
|
||||
}
|
||||
} g;
|
||||
queue<int> Q;
|
||||
int n;
|
||||
int banx, bany;
|
||||
int par[maxn], dis[maxn];
|
||||
int xx, yy;
|
||||
int bfs(int x) {
|
||||
int ret = x;
|
||||
dis[x] = 0;
|
||||
Q.push(x);
|
||||
while (!Q.empty()) {
|
||||
int a = Q.front();
|
||||
Q.pop();
|
||||
for (int p = g.hed[a]; p != -1; p = g.nxt[p]) {
|
||||
int b = g.pnt[p];
|
||||
if (dis[b] != -1) continue;
|
||||
if (a == banx && b == bany || a == bany && b == banx) continue;
|
||||
par[b] = a;
|
||||
dis[b] = dis[a] + g.val[p];
|
||||
Q.push(b);
|
||||
if (dis[b] > dis[ret]) ret = b;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void FindRoad(int x) {
|
||||
memset(par, -1, 4 * n);
|
||||
memset(dis, -1, 4 * n);
|
||||
yy = bfs(x);
|
||||
memset(par, -1, 4 * n);
|
||||
memset(dis, -1, 4 * n);
|
||||
xx = bfs(yy);
|
||||
}
|
||||
int ans;
|
||||
vector<int> v, d;
|
||||
void Solve() {
|
||||
int t, disx, disy, disedge, dxx, dyy;
|
||||
banx = bany = -1;
|
||||
FindRoad(0);
|
||||
v.clear(); d.clear();
|
||||
t = xx;
|
||||
while (true) {
|
||||
v.push_back(t);
|
||||
t = par[t];
|
||||
if (t == -1) break;
|
||||
d.push_back(dis[v.back()] - dis[t]);
|
||||
}
|
||||
ans = dis[xx];
|
||||
for (int i = 1; i < v.size(); i++) {
|
||||
banx = v[i-1]; bany = v[i];
|
||||
disedge = d[i-1];
|
||||
FindRoad(banx);
|
||||
dxx = disx = dis[xx];
|
||||
for (t = xx; t != -1; t = par[t])
|
||||
disx = min(disx, max(dis[xx] - dis[t], dis[t]));
|
||||
FindRoad(bany);
|
||||
dyy = disy = dis[xx];
|
||||
for (t = xx; t != -1; t = par[t])
|
||||
disy = min(disy, max(dis[xx] - dis[t], dis[t]));
|
||||
ans = min(ans, max(max(disx + disy + disedge, dxx), dyy));
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int t, x, y, v, i, cas = 1;
|
||||
for (scanf("%d", &t); t--; ) {
|
||||
scanf("%d", &n);
|
||||
g.init(n);
|
||||
for (i = 1; i < n; i++) {
|
||||
scanf("%d %d %d", &x, &y, &v);
|
||||
g.addedge(x, y, v);
|
||||
}
|
||||
Solve();
|
||||
printf("Case %d: %d\n", cas++, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
#define MAX 201
|
||||
#define MAXN 0xffffff
|
||||
int map[MAX][MAX],link[MAX],dx[MAX],dy[MAX];
|
||||
bool visx[MAX],visy[MAX];
|
||||
int n,lack;
|
||||
char A[201][10001];
|
||||
bool DFS(int v)
|
||||
{
|
||||
visx[v]=true;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
if(visy[i])
|
||||
continue;
|
||||
int t=dx[v]+dy[i]-map[v][i];
|
||||
if(!t)
|
||||
{
|
||||
visy[i]=true;
|
||||
if(link[i]==-1||DFS(link[i]))
|
||||
{
|
||||
link[i]=v;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(t<lack)
|
||||
lack=t;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void KM()
|
||||
{
|
||||
int i,j;
|
||||
memset(dx,0,sizeof(dx));
|
||||
memset(dy,0,sizeof(dy));
|
||||
memset(link,-1,sizeof(link));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
if(map[i][j]>dx[i])
|
||||
dx[i]=map[i][j];
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
while(true)
|
||||
{
|
||||
memset(visx,0,sizeof(visx));
|
||||
memset(visy,0,sizeof(visy));
|
||||
lack=MAXN;
|
||||
if(DFS(i))
|
||||
break;
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if(visx[j])
|
||||
dx[j]-=lack;
|
||||
if(visy[j])
|
||||
dy[j]+=lack;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
for(i=1;i<=n;i++)
|
||||
ans+=map[link[i]][i];
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
void Q()
|
||||
{
|
||||
int i,j,p,q;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
int len1=strlen(A[i]);
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if(i==j)
|
||||
map[i][j]=0;
|
||||
else
|
||||
{
|
||||
int len2=strlen(A[j]);
|
||||
q=0;
|
||||
p=len2-1;
|
||||
while(q<len1&&p>=0&&A[i][q]==A[j][p])
|
||||
{
|
||||
q++;p--;
|
||||
}
|
||||
map[i][j]=q;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(cin>>n)
|
||||
{
|
||||
int i,j;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
map[i][j]=0;
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%s",A[i]);
|
||||
Q();
|
||||
KM();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct dictree{
|
||||
int num;
|
||||
dictree *child[30];
|
||||
};
|
||||
dictree *root;
|
||||
int ans;
|
||||
struct node
|
||||
{
|
||||
double val;
|
||||
int iid;
|
||||
}p[8];
|
||||
void insert(char *s){
|
||||
int len,i,j;
|
||||
dictree *current,*newnode;
|
||||
len=strlen(s);
|
||||
current=root;
|
||||
for(i=0;i<len;i++){
|
||||
if(current->child[s[i]-'a']!=0){
|
||||
current=current->child[s[i]-'a'];
|
||||
current->num++;
|
||||
}
|
||||
else{
|
||||
newnode=(struct dictree *)malloc(sizeof(struct dictree));
|
||||
for(j=0;j<=26;j++){
|
||||
newnode->child[j]=NULL;
|
||||
}
|
||||
newnode->num=1;
|
||||
current->child[s[i]-'a']=newnode;
|
||||
current=current->child[s[i]-'a'];
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
void search(char *s){
|
||||
dictree *current;
|
||||
int i,j,len;
|
||||
current=root;
|
||||
len=strlen(s);
|
||||
for(i=0;i<len;i++){
|
||||
if(current->child[s[i]-'a']!=0){
|
||||
current=current->child[s[i]-'a'];
|
||||
}
|
||||
else{
|
||||
return;
|
||||
}
|
||||
}
|
||||
ans+=current->num;
|
||||
}
|
||||
int cmp(node a,node b)
|
||||
{
|
||||
if(a.val==b.val)return a.iid<b.iid;
|
||||
return a.val<b.val;
|
||||
}
|
||||
int pow(int x){
|
||||
int ans,i;
|
||||
ans=1;
|
||||
for(i=1;i<=x;i++)ans*=2;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double key=105.0/95;
|
||||
int n,m,i,j,asc;
|
||||
char s[120],s1[120];
|
||||
while(scanf("%d%d",&n,&m)!=EOF){
|
||||
root=(struct dictree *)malloc(sizeof(struct dictree));
|
||||
for(i=0;i<=26;i++)root->child[i]=0;
|
||||
root->num=0;
|
||||
for(i=1;i<=n;i++){
|
||||
scanf("%s",s);
|
||||
insert(s);
|
||||
}
|
||||
ans=0;
|
||||
int k,t;
|
||||
for(i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d",&k);
|
||||
for(j=0;j<k;j++)
|
||||
{
|
||||
int kk=0;
|
||||
for(t=0;t<8;t++)
|
||||
{
|
||||
scanf("%lf",&p[t].val);
|
||||
p[t].iid=7-t;
|
||||
}
|
||||
int pp,qq;node tem;
|
||||
for(pp=0;pp<7;pp++)
|
||||
for(qq=pp+1;qq<8;qq++)
|
||||
if(p[pp].val>p[qq].val){
|
||||
tem=p[pp];
|
||||
p[pp]=p[qq];
|
||||
p[qq]=tem;
|
||||
}
|
||||
int tto=1;
|
||||
while(p[tto].val/p[tto-1].val<=key)tto++;
|
||||
asc=0;
|
||||
for(t=tto;t<8;t++){
|
||||
asc+=pow(p[t].iid);
|
||||
}
|
||||
s1[j]=asc;
|
||||
}
|
||||
s1[k]='\0';
|
||||
search(s1);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
const int N=30000+10;
|
||||
typedef long long LL;
|
||||
struct Point{
|
||||
LL x,y;
|
||||
Point (LL a=0,LL b=0):x(a),y(b){}
|
||||
Point operator - (const Point &p)const{
|
||||
return Point(x - p.x, y - p.y);
|
||||
}
|
||||
};
|
||||
LL sum[N],Ti[N],ti;
|
||||
int n,M,r,anger[N];
|
||||
typedef Point Vector;
|
||||
LL Cross(const Vector &u,const Vector &v){
|
||||
return u.x*v.y - u.y*v.x;
|
||||
}
|
||||
struct dequeue{
|
||||
Point q[N];
|
||||
int head,tail;
|
||||
void init(){
|
||||
head = 1; tail = 0;
|
||||
}
|
||||
void push(const Point &u){
|
||||
while (head < tail && Cross(q[tail] - q[tail-1],u - q[tail-1]) <= 0)
|
||||
tail--;
|
||||
q[++tail] = u;
|
||||
}
|
||||
void pop(int k,int i,int w){
|
||||
while (head <= tail && anger[i] - anger[q[head].x] > w) head++;
|
||||
while (head < tail && -k*q[head].x + q[head].y >= -k*q[head+1].x + q[head+1].y) head++;
|
||||
}
|
||||
}H;
|
||||
struct vegetable{
|
||||
int vi,ai;
|
||||
LL di;
|
||||
vegetable(int v=0,int a=0,LL d=0):vi(v),ai(a),di(d){}
|
||||
bool operator < (const vegetable &p)const{
|
||||
return vi>p.vi;
|
||||
}
|
||||
void input(){
|
||||
scanf("%d%d%I64d",&vi,&ai,&di);
|
||||
}
|
||||
void output(){
|
||||
cout<< vi <<" "<< ai <<" "<< di << endl;
|
||||
}
|
||||
}vg[N];
|
||||
void init(){
|
||||
sort(vg+1,vg+n+1);
|
||||
anger[0] = sum[0] = Ti[0] = 0;
|
||||
for (int i=1;i<=n;i++) {
|
||||
sum[i]=sum[i-1]+vg[i].di;
|
||||
Ti[i]=Ti[i-1]+i*vg[i].di;
|
||||
anger[i] = anger[i-1] + vg[i].ai;
|
||||
}
|
||||
}
|
||||
LL dp[11][N];
|
||||
int check(int m){
|
||||
for (int i=0;i<=n;i++){
|
||||
if (anger[i] <= m) dp[0][i]=Ti[i];
|
||||
else dp[0][i] = Ti[i]+ti ;
|
||||
}
|
||||
for (int j=1;j<=M;j++){
|
||||
H.init();
|
||||
H.push(Point(0,(j-1)*r));
|
||||
for (int i=1;i<=n;i++){
|
||||
H.pop(sum[i],i,m);
|
||||
if (H.head<=H.tail)
|
||||
dp[j][i] = -sum[i]*H.q[H.head].x + H.q[H.head].y + Ti[i] + r;
|
||||
else dp[j][i] = ti + 100;
|
||||
if (dp[j-1][i] < ti) H.push(Point(i,sum[i]*i + dp[j-1][i] - Ti[i]));
|
||||
}
|
||||
}
|
||||
LL ret = dp[0][n];
|
||||
for (int i=1; i<=M;i++){
|
||||
if(dp[i][n] < ret) ret = dp[i][n];
|
||||
}
|
||||
if (ret > ti) return 0;
|
||||
return 1;
|
||||
}
|
||||
void solve(int l,int r){
|
||||
init();
|
||||
int ret=-1;
|
||||
while (r>=l){
|
||||
int m=(l+r)>>1;
|
||||
if (check(m)){
|
||||
ret=m; r=m-1;
|
||||
}else l=m+1;
|
||||
}
|
||||
if (ret == -1) printf("I have no idea\n");
|
||||
else printf("%d\n",ret);
|
||||
}
|
||||
int main(){
|
||||
int T; scanf("%d",&T);
|
||||
while (T--){
|
||||
scanf("%d%d%d%I64d",&n,&M,&r,&ti);
|
||||
int allai = 0;
|
||||
for (int i=1;i<=n;i++){
|
||||
vg[i].input();
|
||||
allai += vg[i].ai;
|
||||
}
|
||||
solve(1,allai);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,240 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
using namespace std;
|
||||
#define Key_value ch[ch[root][1]][0]
|
||||
const int MAXN = 20010;
|
||||
int pre[MAXN],ch[MAXN][2],key[MAXN],size[MAXN];
|
||||
int root;
|
||||
void NewNode(int &r,int father,int loc,int k)
|
||||
{
|
||||
r = loc;
|
||||
pre[r] = father;
|
||||
ch[r][0] = ch[r][1] = 0;
|
||||
key[r] = k;
|
||||
size[r] = 1;
|
||||
}
|
||||
void push_up(int r)
|
||||
{
|
||||
size[r] = size[ch[r][0]] + size[ch[r][1]] + 1;
|
||||
}
|
||||
void Init()
|
||||
{
|
||||
root = 0;
|
||||
ch[root][0] = ch[root][1] = key[root] = size[root] = 0;
|
||||
pre[root] = 0;
|
||||
}
|
||||
void Rotate(int x,int kind)
|
||||
{
|
||||
int y = pre[x];
|
||||
ch[y][!kind] = ch[x][kind];
|
||||
pre[ch[x][kind]] = y;
|
||||
if(pre[y])
|
||||
ch[pre[y]][ch[pre[y]][1]==y] = x;
|
||||
pre[x] = pre[y];
|
||||
ch[x][kind] = y;
|
||||
pre[y] = x;
|
||||
push_up(y);
|
||||
}
|
||||
void Splay(int r,int goal)
|
||||
{
|
||||
while(pre[r] != goal)
|
||||
{
|
||||
if(pre[pre[r]] == goal)
|
||||
Rotate(r,ch[pre[r]][0] == r);
|
||||
else
|
||||
{
|
||||
int y = pre[r];
|
||||
int kind = ch[pre[y]][0]==y;
|
||||
if(ch[y][kind] == r)
|
||||
{
|
||||
Rotate(r,!kind);
|
||||
Rotate(r,kind);
|
||||
}
|
||||
else
|
||||
{
|
||||
Rotate(y,kind);
|
||||
Rotate(r,kind);
|
||||
}
|
||||
}
|
||||
}
|
||||
push_up(r);
|
||||
if(goal == 0) root = r;
|
||||
}
|
||||
int Get_kth(int r,int k)
|
||||
{
|
||||
int t = size[ch[r][0]] + 1;
|
||||
if(t == k)return r;
|
||||
if(t > k)return Get_kth(ch[r][0],k);
|
||||
else return Get_kth(ch[r][1],k-t);
|
||||
}
|
||||
void Insert(int loc,int k)
|
||||
{
|
||||
int r = root;
|
||||
if(r == 0)
|
||||
{
|
||||
NewNode(root,0,loc,k);
|
||||
return;
|
||||
}
|
||||
while(ch[r][key[r]<k])
|
||||
r = ch[r][key[r]<k];
|
||||
NewNode(ch[r][key[r]<k],r,loc,k);
|
||||
Splay(ch[r][key[r]<k],0);
|
||||
}
|
||||
struct Edge
|
||||
{
|
||||
int u,v;
|
||||
}edge[60010];
|
||||
bool used[60010];
|
||||
int to[400010];
|
||||
int ne[400010];
|
||||
int head[20010];
|
||||
int tot;
|
||||
void add_value(int x,int v)
|
||||
{
|
||||
to[tot] = v;
|
||||
ne[tot] = head[x];
|
||||
head[x] = tot++;
|
||||
}
|
||||
struct Query
|
||||
{
|
||||
char op[5];
|
||||
int x,y;
|
||||
}query[400010];
|
||||
int q_num;
|
||||
int F[20010];
|
||||
int find(int x)
|
||||
{
|
||||
if(F[x] == -1)return x;
|
||||
else return F[x] = find(F[x]);
|
||||
}
|
||||
void erase(int r)
|
||||
{
|
||||
if(!r)return;
|
||||
erase(ch[r][0]);
|
||||
erase(ch[r][1]);
|
||||
Insert(r,to[head[r]]);
|
||||
}
|
||||
int Get_Min(int r)
|
||||
{
|
||||
while(ch[r][0])
|
||||
{
|
||||
r = ch[r][0];
|
||||
}
|
||||
return r;
|
||||
}
|
||||
void Delete()
|
||||
{
|
||||
if(ch[root][0] == 0 || ch[root][1] == 0)
|
||||
{
|
||||
root = ch[root][0] + ch[root][1];
|
||||
pre[root] = 0;
|
||||
return;
|
||||
}
|
||||
int k = Get_Min(ch[root][1]);
|
||||
Splay(k,root);
|
||||
Key_value = ch[root][0];
|
||||
root = ch[root][1];
|
||||
pre[ch[root][0]] = root;
|
||||
pre[root] = 0;
|
||||
push_up(root);
|
||||
}
|
||||
void bing(int x,int y)
|
||||
{
|
||||
int t1 = find(x),t2 = find(y);
|
||||
if(t1 == t2)return;
|
||||
F[t1] = t2;
|
||||
Splay(t1,0);
|
||||
Splay(t2,0);
|
||||
if(size[t1] > size[t2])
|
||||
swap(t1,t2);
|
||||
root = t2;
|
||||
erase(t1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int N,M;
|
||||
int iCase = 0;
|
||||
while(scanf("%d%d",&N,&M) == 2 )
|
||||
{
|
||||
if(N == 0 && M == 0) break;
|
||||
iCase++;
|
||||
memset(head,-1,sizeof(head));
|
||||
tot = 0;
|
||||
int v;
|
||||
for(int i = 1;i <= N;i++)
|
||||
{
|
||||
scanf("%d",&v);
|
||||
add_value(i,v);
|
||||
}
|
||||
for(int i = 1;i <= M;i++)
|
||||
{
|
||||
scanf("%d%d",&edge[i].u,&edge[i].v);
|
||||
}
|
||||
q_num = 0;
|
||||
memset(used,false,sizeof(used));
|
||||
while(scanf("%s",&query[q_num].op) == 1)
|
||||
{
|
||||
if(query[q_num].op[0] == 'E')break;
|
||||
if(query[q_num].op[0] == 'D')
|
||||
{
|
||||
scanf("%d",&query[q_num].x);
|
||||
used[query[q_num].x] = true;
|
||||
}
|
||||
else if(query[q_num].op[0] == 'Q')
|
||||
scanf("%d%d",&query[q_num].x,&query[q_num].y);
|
||||
else if(query[q_num].op[0] == 'C')
|
||||
{
|
||||
scanf("%d%d",&query[q_num].x,&query[q_num].y);
|
||||
add_value(query[q_num].x,query[q_num].y);
|
||||
}
|
||||
q_num++;
|
||||
}
|
||||
memset(F,-1,sizeof(F));
|
||||
for(int i = 1;i <= N;i++)
|
||||
NewNode(root,0,i,to[head[i]]);
|
||||
for(int i = 1;i <= M;i++)
|
||||
if(!used[i])
|
||||
bing(edge[i].u,edge[i].v);
|
||||
double ans = 0;
|
||||
int cnt = 0;
|
||||
for(int i = q_num-1; i>= 0 ;i--)
|
||||
{
|
||||
if(query[i].op[0] == 'Q')
|
||||
{
|
||||
Splay(query[i].x,0);
|
||||
if(size[root] < query[i].y || query[i].y <= 0)
|
||||
{
|
||||
cnt++;
|
||||
continue;
|
||||
}
|
||||
ans += key[Get_kth(root,size[root] - query[i].y + 1)];
|
||||
cnt++;
|
||||
}
|
||||
else if(query[i].op[0] == 'D')
|
||||
{
|
||||
int tmp = query[i].x;
|
||||
bing(edge[tmp].u,edge[tmp].v);
|
||||
}
|
||||
else if(query[i].op[0] == 'C')
|
||||
{
|
||||
Splay(query[i].x,0);
|
||||
Delete();
|
||||
head[query[i].x] = ne[head[query[i].x]];
|
||||
Insert(query[i].x,to[head[query[i].x]]);
|
||||
}
|
||||
}
|
||||
if(cnt == 0)cnt = 1;
|
||||
printf("Case %d: %.6lf\n",iCase,ans/cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
# include <cstdio>
|
||||
# include <cstring>
|
||||
# include <map>
|
||||
using namespace std;
|
||||
# define N 100005
|
||||
int arr[20][N];
|
||||
struct node
|
||||
{
|
||||
int s,e,layer;
|
||||
int c;
|
||||
}st[4*N];
|
||||
int q[500000][4],c;
|
||||
int remap[N],position[N];
|
||||
map<int,int> refer;
|
||||
void init(int s,int e,int layer,int pos=1)
|
||||
{
|
||||
st[pos].s=s;st[pos].e=e;
|
||||
st[pos].layer=layer;
|
||||
st[pos].c=st[pos].s;
|
||||
if(s!=e) init(s,(s+e)/2,layer+1,pos<<1),init((s+e)/2+1,e,layer+1,(pos<<1)+1);
|
||||
}
|
||||
void insert(int value,int pos=1)
|
||||
{
|
||||
if(st[pos].s==st[pos].e)
|
||||
arr[st[pos].layer][st[pos].c++]=value;
|
||||
else
|
||||
{
|
||||
if(value<=(st[pos].s+st[pos].e)/2)
|
||||
{
|
||||
arr[st[pos].layer][st[pos].c]=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])+1;
|
||||
st[pos].c++;
|
||||
insert(value,pos<<1);
|
||||
}
|
||||
else
|
||||
{
|
||||
arr[st[pos].layer][st[pos].c]=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1]);
|
||||
st[pos].c++;
|
||||
insert(value,(pos<<1)+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
int q1(int s,int t,int k,int pos=1)
|
||||
{
|
||||
if(st[pos].s==st[pos].e)
|
||||
return remap[arr[st[pos].layer][st[pos].s]];
|
||||
else
|
||||
{
|
||||
if(arr[st[pos].layer][t]-(s==st[pos].s?0:arr[st[pos].layer][s-1])>=k)//left
|
||||
return q1(st[pos].s+(s==st[pos].s?0:arr[st[pos].layer][s-1]),st[pos].s+arr[st[pos].layer][t]-1,k,pos<<1);
|
||||
else//right
|
||||
{
|
||||
k-=arr[st[pos].layer][t]-(s==st[pos].s?0:arr[st[pos].layer][s-1]);
|
||||
return q1((st[pos].s+st[pos].e)/2+1+s-1-st[pos].s+1-(s==st[pos].s?0:arr[st[pos].layer][s-1]),(st[pos].s+st[pos].e)/2+1+t-st[pos].s+1-arr[st[pos].layer][t]-1,k,(pos<<1)+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
int q2(int s,int pos=1)
|
||||
{
|
||||
if(st[pos].s==st[pos].e) return 1;
|
||||
else if(arr[st[pos].layer][s]-(s==st[pos].s?0:arr[st[pos].layer][s-1]))
|
||||
return q2(st[pos].s+arr[st[pos].layer][s]-1,pos<<1);
|
||||
else
|
||||
return (st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])+q2((st[pos].s+st[pos].e)/2+1+s-st[pos].s+1-arr[st[pos].layer][s]-1,(pos<<1)+1);
|
||||
}
|
||||
int q3(int k,int pos=1)
|
||||
{
|
||||
if(st[pos].s==st[pos].e) return remap[arr[st[pos].layer][st[pos].s]];
|
||||
else if(k<=(st[pos].c==st[pos].s?0:arr[st[pos].layer][st[pos].c-1])) return q3(k,pos<<1);
|
||||
else return q3(k-(st[pos].s==st[pos].c?0:arr[st[pos].layer][st[pos].c-1]),(pos<<1)+1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,test=1;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
refer.clear();c=1;
|
||||
memset(arr,0,sizeof(arr));
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
char tmp[12];
|
||||
scanf("%s",tmp);
|
||||
if(*tmp=='I')
|
||||
q[i][0]=0;
|
||||
else q[i][0]=tmp[6]-48;
|
||||
switch(q[i][0])
|
||||
{
|
||||
case 0:
|
||||
scanf("%d",&q[i][1]);
|
||||
refer[q[i][1]]=0;
|
||||
break;
|
||||
case 1:
|
||||
scanf("%d%d%d",&q[i][1],&q[i][2],&q[i][3]);
|
||||
break;
|
||||
default:
|
||||
scanf("%d",&q[i][1]);
|
||||
break;
|
||||
};
|
||||
}
|
||||
for(map<int,int>::iterator i=refer.begin();i!=refer.end();i++)
|
||||
remap[c]=i->first,i->second=c++;
|
||||
init(1,c-1,0);
|
||||
long long t[4]={0,0,0,0};
|
||||
int now=1;
|
||||
for(int i=0;i<n;i++)
|
||||
switch(q[i][0])
|
||||
{
|
||||
case 0:
|
||||
insert(refer[q[i][1]]);
|
||||
position[refer[q[i][1]]]=now++;
|
||||
break;
|
||||
case 1:
|
||||
t[1]+=q1(q[i][1],q[i][2],q[i][3]);
|
||||
break;
|
||||
case 2:
|
||||
t[2]+=q2(position[refer[q[i][1]]]);
|
||||
break;
|
||||
case 3:
|
||||
t[3]+=q3(q[i][1]);
|
||||
break;
|
||||
};
|
||||
printf("Case %d:\n%I64d\n%I64d\n%I64d\n",test++,t[1],t[2],t[3]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define N 100005
|
||||
int mark[N],link[N];
|
||||
struct node
|
||||
{
|
||||
int x,y;
|
||||
}a[105];
|
||||
int ss[105];
|
||||
int n;
|
||||
int dfs(int t)
|
||||
{
|
||||
int i;
|
||||
for(i=a[t].x;i<=a[t].y;i++)
|
||||
{
|
||||
if(mark[i]==-1)
|
||||
{
|
||||
mark[i]=1;
|
||||
if(link[i]==-1||dfs(link[i]))
|
||||
{
|
||||
link[i]=t;
|
||||
ss[t]=1;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
int i;
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d%d",&a[i].x,&a[i].y);
|
||||
memset(link,-1,sizeof(link));
|
||||
memset(ss,0,sizeof(ss));
|
||||
int sum;
|
||||
sum=0;
|
||||
for(i=n;i>=1;i--)
|
||||
{
|
||||
memset(mark,-1,sizeof(mark));
|
||||
if(dfs(i))
|
||||
sum++;
|
||||
}
|
||||
printf("%d\n",sum);
|
||||
for(i=1;i<=n-1;i++)
|
||||
{
|
||||
if(ss[i]==1)
|
||||
printf("%d ",i);
|
||||
}
|
||||
printf("%d\n",i);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
#define maxn 1000001
|
||||
#define ll __int64
|
||||
struct Node
|
||||
{
|
||||
ll a,b;
|
||||
};
|
||||
Node no[maxn];
|
||||
bool cmp(Node x,Node y)
|
||||
{
|
||||
return x.a<y.a;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
ll i,n;
|
||||
while(scanf("%I64d",&n)!=EOF)
|
||||
{
|
||||
for(i=0;i<n;i++)scanf("%I64d",&no[i].a);
|
||||
for(i=0;i<n;i++)scanf("%I64d",&no[i].b);
|
||||
sort(no,no+n,cmp);
|
||||
ll ans=0;
|
||||
for(i=0;i<n-1;i++)ans+=no[i].a;
|
||||
if((ans+1)*no[i].b>=no[i].a)ans+=no[i].a;
|
||||
else ans+=(ans+1)*no[i].b;
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
const int maxc = 10005;
|
||||
int dp[maxc], re[11][11], cost;
|
||||
void Pack(int v, int c, int k)
|
||||
{
|
||||
for (int m = 1; k > 0; m += m)
|
||||
{
|
||||
if (m > k)
|
||||
m = k;
|
||||
k -= m;
|
||||
int vv = v * m, cc = c * m;
|
||||
for (int j = cost; j - cc >= 0; j--)
|
||||
{
|
||||
if (dp[j] < dp[j-cc] + vv)
|
||||
dp[j] = dp[j-cc] + vv;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n, i, j;
|
||||
int v, c;
|
||||
while (scanf("%d %d", &n, &cost) != EOF)
|
||||
{
|
||||
memset(dp, 0, (cost + 1) * 4);
|
||||
memset(re, 0, sizeof(re));
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%*c%*s %d %d", &v, &c);
|
||||
re[v][c]++;
|
||||
}
|
||||
for (i = 1; i <= 10; i++)
|
||||
for (j = 0; j <= 10; j++)
|
||||
{
|
||||
if (re[i][j] > 0)
|
||||
{
|
||||
Pack(i, j, re[i][j]);
|
||||
}
|
||||
}
|
||||
printf("%d\n", dp[cost]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
const int Mn = 100010;
|
||||
const int Mod = 1e9 + 7;
|
||||
int a[Mn], b[Mn], n;
|
||||
int s[4][Mn];
|
||||
pair<int, int >c[Mn];
|
||||
inline int query(int k, int num){
|
||||
int res(0);
|
||||
for(;k;k -= k &-k)
|
||||
res = (res+s[num][k]) %Mod;
|
||||
return res;
|
||||
}
|
||||
inline void update(int k, int val, int num){
|
||||
for(; k <= n; k += k & -k){
|
||||
s[num][k] = (s[num][k] + val) % Mod;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d", &T);
|
||||
while(T--){
|
||||
memset(s, 0, sizeof(s));
|
||||
scanf("%d", &n);
|
||||
for(int i = 1; i <= n; ++i)
|
||||
scanf("%d", &a[i]),b[i] = a[i];
|
||||
sort(b+1, b+n+1);
|
||||
for(int i = 1; i <= n; ++i){
|
||||
a[i] = lower_bound(b+1, b+n+1,a[i]) - b;
|
||||
c[i] = make_pair(a[i],i);
|
||||
}
|
||||
sort(c+1, c+n+1);
|
||||
long long ans(0);
|
||||
for(int i= 1; i <= n; ++i){
|
||||
long long t0 = query(c[i].second, 0);
|
||||
long long t1 = query(c[i].second, 1);
|
||||
long long t2 = query(n-c[i].second+1,2);
|
||||
long long t3 = query(n-c[i].second+1,3);
|
||||
ans = (ans+(t0-(1+t1) * t1 /2) % Mod *(t2-(1+t3)*t3/2)%Mod) %Mod;
|
||||
update(c[i].second, c[i].second, 0);
|
||||
update(c[i].second, 1, 1);
|
||||
update(n-c[i].second+1, n-c[i].second+1,2);
|
||||
update(n-c[i].second+1,1,3);
|
||||
}
|
||||
printf("%d\n", (int)(ans%Mod+Mod) %Mod);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#define MOD 1000000003
|
||||
#define MAXN 2010
|
||||
using namespace std;
|
||||
using namespace std;
|
||||
long long n, m, b[MAXN], e[MAXN] = {0}, zero[MAXN] = {0};
|
||||
struct poly {
|
||||
long long a[MAXN];
|
||||
poly(long long ta[]) {
|
||||
for (int i = 0; i < 2 * m; i++) a[i] = ta[i];
|
||||
}
|
||||
poly operator*(const poly & po) {
|
||||
poly re(zero);
|
||||
for (int i = 0; i < m; i++) {
|
||||
if (po.a[i])
|
||||
for (int j = 0; j < m; j++) {
|
||||
re.a[i + j] += a[j] * po.a[i];
|
||||
re.a[i + j] %= MOD;
|
||||
}
|
||||
}
|
||||
for (int i = 2 * m - 1; i >= m; i--) {
|
||||
if (re.a[i])
|
||||
for (int j = 0; j < m; j++) {
|
||||
re.a[i + j - m] += b[j] * re.a[i];
|
||||
re.a[i + j - m] %= MOD;
|
||||
}
|
||||
a[i] = 0;
|
||||
}
|
||||
return re;
|
||||
}
|
||||
void left() {
|
||||
for (int i = m - 1; i >= 0; i--) a[i + 1] = a[i];
|
||||
a[0] = 0;
|
||||
for (int j = 0; j < m; j++) {
|
||||
a[j] += b[j] * a[m];
|
||||
a[j] %= MOD;
|
||||
}
|
||||
a[m] = 0;
|
||||
}
|
||||
void square() {
|
||||
long long ans[MAXN] = {0};
|
||||
for (int i = 0; i < m; i++) {
|
||||
if (a[i])
|
||||
for (int j = 0; j < m; j++) {
|
||||
ans[i + j] += a[j] * a[i];
|
||||
ans[i + j] %= MOD;
|
||||
}
|
||||
}
|
||||
for (int i = 2 * m - 1; i >= m; i--) {
|
||||
if (ans[i])
|
||||
for (int j = 0; j < m; j++) {
|
||||
ans[i + j - m] += b[j] * ans[i];
|
||||
ans[i + j - m] %= MOD;
|
||||
}
|
||||
ans[i] = 0;
|
||||
}
|
||||
for (int i = 0; i < 2 * m; i++) a[i] = ans[i];
|
||||
}
|
||||
poly operator^(long long power) {
|
||||
poly re(e), tem(e);
|
||||
if (power <= 0) return re;
|
||||
tem.left();
|
||||
while (power) {
|
||||
if (power & 1) re = re * tem;
|
||||
power >>= 1;
|
||||
tem.square();
|
||||
}
|
||||
return re;
|
||||
}
|
||||
};
|
||||
long long ai[MAXN];
|
||||
int main() {
|
||||
int cc;
|
||||
cin >> cc;
|
||||
e[0] = 1;
|
||||
while (cc--) {
|
||||
cin >> m >> n;
|
||||
memset(ai, 0, sizeof (ai));
|
||||
memset(b, 0, sizeof (b));
|
||||
for (int i = 0; i < m; i++) scanf(" %I64d", ai + i);
|
||||
for (int i = 0; i < m; i++) scanf(" %I64d", b + i);
|
||||
poly tem(b), ta(ai);
|
||||
tem = tem^n;
|
||||
long long ans = 0;
|
||||
for (int i = 0; i < m; i++)
|
||||
ans = (ans + tem.a[i] * ta.a[i]) % MOD;
|
||||
cout << ans << endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#define N 100010
|
||||
int n;
|
||||
__int64 a[N], x, y, z;
|
||||
int q[N], ed;
|
||||
__int64 min(__int64 a,__int64 b )
|
||||
{
|
||||
return a<b?a:b;
|
||||
}
|
||||
void solve() {
|
||||
__int64 res = a[0] * x + a[n - 1] * y;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
res += a[i] * z;
|
||||
if(i) {
|
||||
if (a[i - 1] > a[i])
|
||||
res += (a[i - 1] - a[i]) * y;
|
||||
else
|
||||
res += (a[i] - a[i - 1]) * x;
|
||||
}
|
||||
}
|
||||
ed = 0;
|
||||
q[ed++] = 0;
|
||||
for (int i = 1; i < n; ++i) {
|
||||
if (a[q[ed - 1]] >= a[i]) q[ed++] = i;
|
||||
else {
|
||||
while (ed > 1 && a[q[ed - 1]] < a[i]) {
|
||||
--ed;
|
||||
__int64 tmp, t = min(a[i], a[q[ed - 1]]) - a[q[ed]];
|
||||
if ((tmp = (x + y - (i - q[ed - 1] - 1) * z) * t) > 0) {
|
||||
res -= tmp;
|
||||
}
|
||||
}
|
||||
if (a[q[ed - 1]] <= a[i]) --ed;
|
||||
q[ed++] = i;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n", res);
|
||||
}
|
||||
int main() {
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
while (cas--) {
|
||||
scanf("%d", &n);
|
||||
scanf("%I64d%I64d%I64d", &x, &y, &z);
|
||||
for (int i = 0; i < n; ++i) {
|
||||
scanf("%I64d", &a[i]);
|
||||
}
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
||||
#define INF 0x7fffffff
|
||||
#define MAXN 2010
|
||||
#define MAXM 600000
|
||||
int pt[MAXM], head[MAXN], next[MAXM], flow[MAXM], lvl[MAXN], queue[MAXN];
|
||||
int pos;
|
||||
int arr[MAXN], stage[MAXN];
|
||||
int n;
|
||||
void AddEdge(int a, int b, int c)
|
||||
{
|
||||
pt[++pos] = b;
|
||||
next[pos] = head[a];
|
||||
head[a] = pos;
|
||||
flow[pos] = c;
|
||||
}
|
||||
void Connect(int a, int b, int c)
|
||||
{
|
||||
AddEdge(a, b, c);
|
||||
AddEdge(b, a, 0);
|
||||
}
|
||||
bool bfs(int s, int t)
|
||||
{
|
||||
int qs, qe, v, e;
|
||||
memset (lvl, 0, sizeof lvl);
|
||||
lvl[s] = 1;
|
||||
qs = qe = 0;
|
||||
queue[qe++] = s;
|
||||
while (qs < qe)
|
||||
{
|
||||
v = queue[qs++];
|
||||
for (e = head[v]; e != -1; e = next[e])
|
||||
if (flow[e] > 0 && lvl[pt[e]] == 0)
|
||||
{
|
||||
lvl[pt[e]] = lvl[v] + 1;
|
||||
queue[qe++] = pt[e];
|
||||
}
|
||||
}
|
||||
return lvl[t] > 0;
|
||||
}
|
||||
int Update(int v, int t, int tmpflow)
|
||||
{
|
||||
int tmp, res = 0, e;
|
||||
if (v == t) return tmpflow;
|
||||
for (e = head[v]; e != -1; e = next[e])
|
||||
if (flow[e] > 0 && lvl[pt[e]] == lvl[v] + 1)
|
||||
{
|
||||
tmp = Update(pt[e], t, MIN(flow[e], tmpflow));
|
||||
flow[e] -= tmp; flow[e^1] += tmp;
|
||||
res += tmp;
|
||||
tmpflow -= tmp;
|
||||
if (tmpflow == 0) {break;}
|
||||
}
|
||||
lvl[v] = -1;
|
||||
return res;
|
||||
}
|
||||
int dinic(int s, int t)
|
||||
{
|
||||
int res = 0;
|
||||
while (bfs(s, t))
|
||||
res += Update(s, t, INF);
|
||||
return res;
|
||||
}
|
||||
void GenStage(int n)
|
||||
{
|
||||
int i, j, mx = -1;
|
||||
memset (stage, 0, sizeof stage);
|
||||
for (i = 0; i < n; i++)
|
||||
for (j = i + 1; j < n; j++)
|
||||
if (arr[j] > arr[i])
|
||||
stage[j] = MAX(stage[j], stage[i] + 1);
|
||||
for (i = 0; i < n; i++)
|
||||
for (j = i + 1; j < n; j++)
|
||||
if (stage[i] + 1 == stage[j] && arr[i] < arr[j])
|
||||
Connect(2 * i + 1, 2 * j, INF);
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
mx = MAX(mx, stage[i]);
|
||||
}
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
Connect(2 * i, 2 * i + 1, 1);
|
||||
if (stage[i] == 0)
|
||||
Connect(2 * n, 2 * i, INF);
|
||||
if (stage[i] == mx)
|
||||
Connect(2 * i + 1, 2 * n + 1, INF);
|
||||
}
|
||||
}
|
||||
void Solve()
|
||||
{
|
||||
int i, res;
|
||||
memset (head, -1, sizeof head);
|
||||
pos = -1;
|
||||
scanf("%d", &n);
|
||||
for (i = 0; i < n; i++)
|
||||
scanf("%d", arr + i);
|
||||
GenStage(n);
|
||||
res = dinic(2 * n, 2 * n + 1);
|
||||
printf("%d\n", res);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas;
|
||||
scanf("%d", &cas);
|
||||
while (cas--)
|
||||
Solve();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include "iostream"
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int num,pre;
|
||||
double weight;
|
||||
}no[1009];
|
||||
double rule[1009],dev;
|
||||
int e,res;
|
||||
double w[110],up,down;
|
||||
bool place(int s)
|
||||
{
|
||||
int i,j,k = e;
|
||||
double t;
|
||||
for (i = 0; i < k;i++)
|
||||
{
|
||||
t = no[i].weight + w[s];
|
||||
if (rule[(int)(t/dev)] == -1 && t <= up)
|
||||
{
|
||||
rule[(int)(t/dev)] = t;
|
||||
no[e].num = s;
|
||||
no[e].pre = i;
|
||||
no[e++].weight = t;
|
||||
if (t >= down)
|
||||
{
|
||||
res = e-1;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,n;
|
||||
double sum;
|
||||
no[0].num = -1;
|
||||
no[0].weight = 0;
|
||||
rule[0] = 0;
|
||||
while (scanf("%d",&n) && n)
|
||||
{
|
||||
e = 1;
|
||||
sum = 0;
|
||||
for (i = 1;i <= n;i++)
|
||||
{
|
||||
scanf("%lf",&w[i]);
|
||||
sum += w[i];
|
||||
}
|
||||
down = sum /2.01;
|
||||
up = sum /1.985;
|
||||
dev = sum/1000;
|
||||
for (i = 1;i <= 1000;i++)
|
||||
{
|
||||
rule[i] = -1;
|
||||
}
|
||||
for (i = 1;i <= n;i++)
|
||||
{
|
||||
if(place(i)){
|
||||
printf("%d",no[res].num);
|
||||
i = no[res].pre;
|
||||
while(i > 0)
|
||||
{
|
||||
printf(" %d",no[i].num);
|
||||
i = no[i].pre;
|
||||
}
|
||||
printf("\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn = 1000000 + 10;
|
||||
struct Node{
|
||||
int a, b, val;
|
||||
}node[maxn];
|
||||
int parent[maxn];
|
||||
bool cmp(const Node &a, const Node &b){
|
||||
return a.val < b.val ;
|
||||
}
|
||||
void Init(int num){
|
||||
for(int i=0; i<num; i++)
|
||||
parent[i] = i;
|
||||
}
|
||||
int main(){
|
||||
int n, m;
|
||||
while(cin >>n >>m, n||m){
|
||||
int ans = 0, i;
|
||||
for( i=0; i<m; i++){
|
||||
cin >>node[i].a >>node[i].b >>node[i].val;
|
||||
}
|
||||
sort(node, node+m, cmp);
|
||||
Init(n);
|
||||
for( i=0; i<m; i++){
|
||||
if( node[i].a == parent[node[i].a] || node[i].b == parent[node[i].b])
|
||||
ans = ans > node[i].val ? ans : node[i].val;
|
||||
parent[ node[i].a ] = -1;
|
||||
parent[ node[i].b ] = -1;
|
||||
}
|
||||
for( i=0; i<n; i++)
|
||||
if(parent[i] == i)
|
||||
break;
|
||||
if(i < n)
|
||||
cout <<"IMPOSSIBLE" <<endl;
|
||||
else
|
||||
cout <<ans <<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include"stdio.h"
|
||||
#include"string.h"
|
||||
#include"stdlib.h"
|
||||
int n;
|
||||
int C[1000111];
|
||||
int num[1000111];
|
||||
struct A
|
||||
{
|
||||
int index,num;
|
||||
}T[1000111];
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
struct A *c,*d;
|
||||
c=(struct A *)a;
|
||||
d=(struct A *)b;
|
||||
return c->num-d->num;
|
||||
}
|
||||
int sum(int k)
|
||||
{
|
||||
int t=0;
|
||||
while(k>0)
|
||||
{
|
||||
t+=C[k];
|
||||
k-=k&(-k);
|
||||
}
|
||||
return t;
|
||||
}
|
||||
void update(int k,int dir)
|
||||
{
|
||||
while(k>0 && k<=n)
|
||||
{
|
||||
C[k]+=dir;
|
||||
k+=k&(-k);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
__int64 ans;
|
||||
while(scanf("%d",&n)!=-1)
|
||||
{
|
||||
for(i=1;i<=n;i++) {scanf("%d",&num[i]);T[i].num=num[i];T[i].index=i;}
|
||||
T[0].num=-1;
|
||||
qsort(T,n+1,sizeof(T[0]),cmp);
|
||||
for(i=1;i<=n;i++) num[T[i].index]=i;
|
||||
ans=0;
|
||||
memset(C,0,sizeof(C));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
update(num[i],1);
|
||||
ans+=i-sum(num[i]);
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
using namespace std;
|
||||
#define MAXN 110
|
||||
int t , n , m;
|
||||
int flag;
|
||||
int x[MAXN] , r[MAXN];
|
||||
int tmp_x[MAXN] , tmp_r[MAXN];
|
||||
int search(){
|
||||
for(int i = 1 ; i < n ; i++){
|
||||
if(tmp_x[i] > tmp_x[i-1]) return i;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void solve(){
|
||||
int k;
|
||||
memset(tmp_ , 0 , sizeof(tmp_x));
|
||||
memcpy(tmp_ , r , sizeof(r));
|
||||
sort(tmp_ , tmp_r+n);
|
||||
for(int i = 0 ; i < n ; i++){
|
||||
for(int j = 0 ; j < n ; j++){
|
||||
if(tmp_r[i] == r[j]){
|
||||
tmp_x[i] = x[j] ; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while(k = search()){
|
||||
for(int i = 0 ; i < k ; i++) tmp_x[i] += 400;
|
||||
}
|
||||
if(tmp_x[0] <= m) flag = 1;
|
||||
}
|
||||
int main() {
|
||||
scanf("%d" , &t);
|
||||
while(t--){
|
||||
memset(x , 0 , sizeof(x));
|
||||
memset(r , 0 , sizeof(r));
|
||||
scanf("%d%d" ,&n , &m);
|
||||
for(int i = 0 ; i < n ; i++)
|
||||
scanf("%d%d" , &x[i] , &r[i]);
|
||||
flag = 0 ; solve();
|
||||
if(flag) printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define N 100010
|
||||
char s[N];
|
||||
int nextval[N];
|
||||
int len;
|
||||
void getnext(const char *s)
|
||||
{
|
||||
int i = 0, j = -1;
|
||||
nextval[0] = -1;
|
||||
while(i != len)
|
||||
{
|
||||
if(j == -1 || s[i] == s[j])
|
||||
nextval[++i] = ++j;
|
||||
else
|
||||
j = nextval[j];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase;
|
||||
int length, add;
|
||||
scanf("%d", &ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
scanf("%s", s);
|
||||
len = strlen(s);
|
||||
getnext(s);
|
||||
length = len - nextval[len];
|
||||
if(len != length && len % length == 0)
|
||||
printf("0\n");
|
||||
else
|
||||
{
|
||||
add = length - nextval[len] % length;
|
||||
printf("%d\n",add);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include"stdio.h"
|
||||
int min(int a,int b)
|
||||
{
|
||||
return a>b?b:a;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int y1,y2,y3,y4;
|
||||
int ans;
|
||||
int i;
|
||||
int n;
|
||||
char str1[55],str2[55];
|
||||
while(scanf("%d",&n)!=-1)
|
||||
{
|
||||
scanf("%s%s",str1,str2);
|
||||
y1=0;
|
||||
for(i=0;i<n;i++) if(str1[i]!=str2[i]) y1++;
|
||||
y2=1;
|
||||
for(i=0;i<n;i++) if(str2[i]=='0') y2++;
|
||||
y3=1;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
if(str1[i]=='0') str1[i]='1';
|
||||
else str1[i]='0';
|
||||
}
|
||||
for(i=0;i<n;i++) if(str1[i]!=str2[i]) y3++;
|
||||
y4=2;
|
||||
for(i=0;i<n;i++) if(str2[i]=='1') y4++;
|
||||
ans=min(min(min(y1,y2),y3),y4);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<map>
|
||||
using namespace std;
|
||||
map<int,int> ha[35];
|
||||
int vis[35];
|
||||
int n,v,k;
|
||||
int flag;
|
||||
int constraint;
|
||||
int g[35][35];
|
||||
struct node
|
||||
{
|
||||
int w;
|
||||
int cons;
|
||||
}t[35],s[35];
|
||||
void dfs(int y,int x,int cur)
|
||||
{
|
||||
if(y>k) return;
|
||||
else if(x==constraint) ha[y][cur]=1;
|
||||
else
|
||||
{
|
||||
int tt=0;
|
||||
if(s[x].cons!=-1)
|
||||
{
|
||||
for(int i=0;i<n;i++) if(g[x][i])
|
||||
{
|
||||
if(vis[i])
|
||||
{
|
||||
tt=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(s[x].cons==-1||!tt)
|
||||
{
|
||||
vis[x]=1;
|
||||
dfs(y+1,x+1,cur+s[x].w);
|
||||
vis[x]=0;
|
||||
}
|
||||
dfs(y,x+1,cur);
|
||||
}
|
||||
}
|
||||
void dfs2(int y,int x,int cur)
|
||||
{
|
||||
if(y>k) return;
|
||||
else if(x==n)
|
||||
{
|
||||
if(ha[k-y][v-cur]==1)
|
||||
{
|
||||
flag=1;
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if(!flag)
|
||||
{
|
||||
dfs2(y+1,x+1,cur+s[x].w);
|
||||
dfs2(y,x+1,cur);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
int T;
|
||||
int m;
|
||||
int mark[35];
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d%d",&n,&m,&k,&v);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&t[i].w);
|
||||
t[i].cons=-1;
|
||||
s[i].cons=-1;
|
||||
}
|
||||
int cnt=0;
|
||||
memset(mark,-1,sizeof(mark));
|
||||
memset(g,0,sizeof(g));
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
int t1,t2;
|
||||
int c1,c2;
|
||||
scanf("%d%d",&t1,&t2);
|
||||
t1--;
|
||||
t2--;
|
||||
if(mark[t1]==-1) mark[t1]=cnt++;
|
||||
if(mark[t2]==-1) mark[t2]=cnt++;
|
||||
c1=mark[t1];
|
||||
c2=mark[t2];
|
||||
s[c1].cons=c2;
|
||||
s[c1].w=t[t1].w;
|
||||
t[t1].cons=t2;
|
||||
t[t2].cons=t1;
|
||||
s[c2].cons=c1;
|
||||
s[c2].w=t[t2].w;
|
||||
g[c1][c2]=1;
|
||||
g[c2][c1]=1;
|
||||
}
|
||||
if(cnt>n/2) constraint=cnt;
|
||||
else constraint=n/2+1;
|
||||
for(i=0;i<n;i++) if(t[i].cons==-1)
|
||||
{
|
||||
s[cnt++]=t[i];
|
||||
}
|
||||
for(i=0;i<=k;i++)
|
||||
ha[i].clear();
|
||||
memset(vis,0,sizeof(vis));
|
||||
dfs(0,0,0);
|
||||
flag=0;
|
||||
dfs2(0,constraint,0);
|
||||
if(flag) printf("YES\n");
|
||||
else printf("NO\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
#define MAXN 111111
|
||||
#define MAXM 211111
|
||||
#define eps 1e-8
|
||||
#define INF 1000000001
|
||||
using namespace std;
|
||||
int e, tmpdfn, top;
|
||||
int n, m, ind;
|
||||
int vis[MAXM], head[MAXN], dfn[MAXN], low[MAXN], num[MAXM];
|
||||
vector<int>g[MAXN];
|
||||
struct Edge
|
||||
{
|
||||
int v, next;
|
||||
}edge[MAXM];
|
||||
void add(int u, int v)
|
||||
{
|
||||
edge[e].v = v;
|
||||
edge[e].next = head[u];
|
||||
head[u] = e++;
|
||||
edge[e].v = u;
|
||||
edge[e].next = head[v];
|
||||
head[v] = e++;
|
||||
}
|
||||
struct Stack
|
||||
{
|
||||
int s, e;
|
||||
Stack(){}
|
||||
Stack(int a, int b){s = a; e = b;}
|
||||
}st[MAXM];
|
||||
void init()
|
||||
{
|
||||
e = tmpdfn = ind = 0;
|
||||
top = -1;
|
||||
memset(vis, 0, sizeof(vis));
|
||||
memset(dfn, 0, sizeof(dfn));
|
||||
memset(head, -1, sizeof(head));
|
||||
memset(num, 0, sizeof(num));
|
||||
}
|
||||
void color(Stack t)
|
||||
{
|
||||
ind++;
|
||||
while(top >= 0)
|
||||
{
|
||||
Stack A = st[top--];
|
||||
g[A.s].push_back(ind);
|
||||
g[A.e].push_back(ind);
|
||||
if(A.s == t.s && A.e == t.e) break;
|
||||
}
|
||||
}
|
||||
void dfs(int u, int fa)
|
||||
{
|
||||
dfn[u] = low[u] = ++tmpdfn;
|
||||
for(int i = head[u]; i != -1; i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].v;
|
||||
if(vis[i] == 0)
|
||||
{
|
||||
vis[i] = vis[i ^ 1] = 1;
|
||||
Stack tmp(u, v);
|
||||
st[++top] = tmp;
|
||||
if(!dfn[v])
|
||||
{
|
||||
dfs(v, u);
|
||||
low[u] = min(low[u], low[v]);
|
||||
if(low[v] >= dfn[u]) color(tmp);
|
||||
}
|
||||
else if(v != fa) low[u] = min(low[u], dfn[v]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int Q;
|
||||
int uu[MAXM], vv[MAXM];
|
||||
int fa[MAXN];
|
||||
int find(int x)
|
||||
{
|
||||
if(fa[x] == x) return x;
|
||||
int t = find(fa[x]);
|
||||
fa[x] = t;
|
||||
return t;
|
||||
}
|
||||
void join(int u, int v)
|
||||
{
|
||||
int fx = find(u);
|
||||
int fy = find(v);
|
||||
if(fx != fy) fa[fx] = fy;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int u, v;
|
||||
int cas = 0;
|
||||
while(scanf("%d%d%d", &n, &m, &Q) != EOF)
|
||||
{
|
||||
if(n == 0 && m == 0 && Q == 0) break;
|
||||
init();
|
||||
for(int i = 1; i <= n; i++) fa[i] = i;
|
||||
for(int i = 0; i < m; i++)
|
||||
{
|
||||
scanf("%d%d", &uu[i], &vv[i]);
|
||||
uu[i]++; vv[i]++;
|
||||
add(uu[i], vv[i]);
|
||||
join(uu[i], vv[i]);
|
||||
}
|
||||
for(int i = 1; i <= n; i++) g[i].clear();
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
if(!dfn[i]) dfs(i, 0);
|
||||
}
|
||||
for(int i = 1; i <= n; i++) sort(g[i].begin(), g[i].end());
|
||||
for(int i = 1; i <= n; i++) unique(g[i].begin(), g[i].end());
|
||||
for(int i = 0; i < m; i++)
|
||||
{
|
||||
int sz1 = g[uu[i]].size();
|
||||
int sz2 = g[vv[i]].size();
|
||||
int k1 = 0, k2 = 0;
|
||||
while(k1 < sz1 && k2 < sz2)
|
||||
{
|
||||
if(g[uu[i]][k1] > g[vv[i]][k2]) k2++;
|
||||
else if(g[uu[i]][k1] < g[vv[i]][k2]) k1++;
|
||||
else if(g[uu[i]][k1] == g[vv[i]][k2])
|
||||
{
|
||||
int tmp = g[uu[i]][k1];
|
||||
num[tmp]++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d:\n", ++cas);
|
||||
for(int i = 0; i < Q; i++)
|
||||
{
|
||||
scanf("%d%d", &u, &v);
|
||||
u++; v++;
|
||||
int sz1 = g[u].size();
|
||||
int sz2 = g[v].size();
|
||||
int k1 = 0, k2 = 0;
|
||||
int tmp = -1;
|
||||
while(k1 < sz1 && k2 < sz2)
|
||||
{
|
||||
if(g[u][k1] > g[v][k2]) k2++;
|
||||
else if(g[u][k1] < g[v][k2]) k1++;
|
||||
else if(g[u][k1] == g[v][k2])
|
||||
{
|
||||
tmp = g[u][k1];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(find(u) != find(v)) puts("zero");
|
||||
else if(tmp == -1) puts("one");
|
||||
else if(num[tmp] == 1) puts("one");
|
||||
else puts("two or more");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
#include<cstring>
|
||||
#include<stdio.h>
|
||||
double a[100005];
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
int N;
|
||||
a[0]=0;
|
||||
a[1]=1;
|
||||
a[2]=3.0;
|
||||
for(i=3;i<100001;i++)
|
||||
{
|
||||
k=(1+i)/2;
|
||||
a[i]=a[k-1]+k-1+a[i-k]+i-k+1;
|
||||
}
|
||||
while(cin>>N)
|
||||
{
|
||||
printf("%.2lf\n",a[N]/N);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
while(n--)
|
||||
{
|
||||
int a, b;
|
||||
scanf("%d%d", &a, &b);
|
||||
if(a % 2 == 1|| b > a / 2)
|
||||
printf("NO\n");
|
||||
else
|
||||
printf("YES\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <cmath>
|
||||
#include <sstream>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
string tmp,str[1111][190];
|
||||
int len[190],T,num[1111];
|
||||
int main(){
|
||||
scanf("%d",&T);
|
||||
while(T --){
|
||||
memset(len,0,sizeof(len));
|
||||
memset(num,0,sizeof(num));
|
||||
int nNum = 0;
|
||||
while(getline(cin,tmp) && tmp != "@"){
|
||||
if(tmp == "") continue;
|
||||
istringstream strin(tmp);
|
||||
int j = 0;
|
||||
nNum ++;
|
||||
while(strin >> tmp){
|
||||
str[nNum][++ j] = tmp;
|
||||
if(tmp.size() > len[j]) len[j]= tmp.size();
|
||||
}
|
||||
num[nNum] = j;
|
||||
}
|
||||
cout << setiosflags(ios :: left);
|
||||
for(int i = 1; i <= nNum; i ++){
|
||||
for(int j = 1; j < num[i]; j ++){
|
||||
cout << setw(len[j] + 1) << str[i][j];
|
||||
}
|
||||
cout << str[i][num[i]] << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include <cstdio>
|
||||
typedef unsigned long long ullong;
|
||||
int eval(int f[], int x, ullong k){
|
||||
bool vst[10];
|
||||
for(int i = 0;i < 10; ++i) vst[i] = false;
|
||||
vst[x] = true;
|
||||
while(k--){
|
||||
x = f[x];
|
||||
if(vst[x]){
|
||||
int len = 1;
|
||||
for(int y = f[x];y != x;y = f[y]) ++len;
|
||||
k %= len;
|
||||
while(k--) x = f[x];
|
||||
return x;
|
||||
}
|
||||
else vst[x] = true;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
int g[10][10];
|
||||
ullong min(ullong a, ullong b){
|
||||
return a < b ? a : b;
|
||||
}
|
||||
int main(){
|
||||
int TT;
|
||||
scanf("%d", &TT);
|
||||
for(int cas = 1; cas <= TT; ++cas){
|
||||
for(int i = 0;i < 10; ++i){
|
||||
for(int j = 0;j < 10; ++j){
|
||||
scanf("%d", g[j] + i);
|
||||
}
|
||||
}
|
||||
ullong a, b;
|
||||
scanf("%I64u %I64u", &a, &b);
|
||||
ullong ans = 0;
|
||||
for(ullong t = 1;t <= b;t *= 10){
|
||||
ullong u = a, v = b;
|
||||
int d = u / t % 10;
|
||||
ullong uu = min((u / t + 1) * t - 1, v);
|
||||
int val = eval(g[d], d, uu - u);
|
||||
for(++d, u = uu;d < 10 && u < v; ++d, u = uu){
|
||||
uu = min(u + t, v);
|
||||
val = eval(g[d], val, uu - u);
|
||||
}
|
||||
if((v - u) / t >= 10){
|
||||
int f[10];
|
||||
for(int d = 0;d < 10; ++d){
|
||||
f[d] = d;
|
||||
for(int j = 0;j < 10; ++j){
|
||||
f[d] = eval(g[j], f[d], t);
|
||||
}
|
||||
}
|
||||
val = eval(f, val, (v - u) / t / 10);
|
||||
u += (v - u) / t / 10 * t * 10;
|
||||
}
|
||||
for(d = 0; u < v; ++d, u = uu){
|
||||
uu = min(u + t, v);
|
||||
val = eval(g[d], val, uu - u);
|
||||
}
|
||||
ans += val * t;
|
||||
}
|
||||
printf("%I64u\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define eps 1e-6
|
||||
const double pi = acos(-1.0);
|
||||
struct Point {
|
||||
double x, y, z;
|
||||
double v, h;
|
||||
void SCANF() {
|
||||
scanf("%lf %lf %lf", &x, &y, &z);
|
||||
v = z;
|
||||
h = sqrt(x*x + y*y);
|
||||
}
|
||||
}pt[ 10001 ];
|
||||
int n;
|
||||
double MaxH, MaxV;
|
||||
double Calc(double R) {
|
||||
int i;
|
||||
double Max = 0;
|
||||
int idx = 0;
|
||||
for(i = 0; i < n; i++) {
|
||||
double nv = pt[i].v / (R - pt[i].h);
|
||||
if(nv > Max) {
|
||||
Max = nv;
|
||||
idx = i;
|
||||
}
|
||||
}
|
||||
return Max * R;
|
||||
}
|
||||
int main() {
|
||||
int t;
|
||||
int i;
|
||||
scanf("%d", &t);
|
||||
while(t--) {
|
||||
scanf("%d", &n);
|
||||
MaxH = MaxV = 0;
|
||||
for(i = 0; i < n; i++) {
|
||||
pt[i].SCANF();
|
||||
if(pt[i].h > MaxH)
|
||||
MaxH = pt[i].h;
|
||||
if(pt[i].v > MaxV)
|
||||
MaxV = pt[i].v;
|
||||
}
|
||||
double l = MaxH + eps, r = 1e6;
|
||||
double ml, mr;
|
||||
while(l + 1e-6 < r) {
|
||||
ml = (2 * l + r) / 3;
|
||||
mr = (l + 2 * r) / 3;
|
||||
double lans = Calc(ml) * ml * ml;
|
||||
double rans = Calc(mr) * mr * mr;
|
||||
if( lans > rans ) {
|
||||
l = ml + 1e-5;
|
||||
}else
|
||||
r = mr - 1e-5;
|
||||
}
|
||||
double ans = (l + r) / 2;
|
||||
printf("%.3lf %.3lf\n", Calc(ans), ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const long long inf=(1LL)<<60;
|
||||
short path[4010][4010];
|
||||
long long f[4010];
|
||||
struct node
|
||||
{
|
||||
long long d;
|
||||
int num;
|
||||
int sh;
|
||||
}x[4010],y[4010];
|
||||
int n,m;
|
||||
bool cmpd(node a,node b)
|
||||
{
|
||||
return a.d<b.d;
|
||||
}
|
||||
bool cmpnum(node a,node b)
|
||||
{
|
||||
return a.num<b.num;
|
||||
}
|
||||
void solve(int i,int j)
|
||||
{
|
||||
if(i!=1) solve(i-1,path[i][j]);
|
||||
x[i].sh=y[j].num;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int sec;
|
||||
scanf("%d",&sec);
|
||||
for(int z=1;z<=sec;z++)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%I64d",&x[i].d);
|
||||
x[i].num=i;
|
||||
}
|
||||
scanf("%d",&m);
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%I64d",&y[i].d);
|
||||
y[i].num=i;
|
||||
}
|
||||
sort(x+1,x+1+n,cmpd);
|
||||
sort(y+1,y+1+m,cmpd);
|
||||
for(int i=0;i<=max(n,m);i++)
|
||||
f[i]=inf;
|
||||
f[1]=abs(x[1].d-y[1].d);
|
||||
for(int i=2;i<=n;i++)
|
||||
for(int j=min(i,m);j>=1;j--)
|
||||
{
|
||||
if(f[j]<f[j-1])
|
||||
{
|
||||
f[j]=f[j]+abs(x[i].d-y[j].d);
|
||||
path[i][j]=j;
|
||||
}
|
||||
else
|
||||
{
|
||||
f[j]=f[j-1]+abs(x[i].d-y[j].d);
|
||||
path[i][j]=j-1;
|
||||
}
|
||||
}
|
||||
printf("%I64d\n",f[m]);
|
||||
solve(n,m);
|
||||
sort(x+1,x+1+n,cmpnum);
|
||||
for(int i=1;i<=n-1;i++)
|
||||
printf("%d ",x[i].sh);
|
||||
printf("%d\n",x[n].sh);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#define MAXN 100005
|
||||
#define MAXM 400005
|
||||
#define INF 1000000011
|
||||
#define lch(x) x<<1
|
||||
#define rch(x) x<<1|1
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
#define eps 1e-7
|
||||
using namespace std;
|
||||
bool tag[10001];
|
||||
int p[10001];
|
||||
int cnt;
|
||||
void get_prime()
|
||||
{
|
||||
cnt = 0;
|
||||
tag[1] = 1;
|
||||
for (int i = 2; i < 10000; i++)
|
||||
{
|
||||
if (!tag[i])
|
||||
p[cnt++] = i;
|
||||
for (int j = 0; j < cnt && p[j] * i < 10000; j++)
|
||||
{
|
||||
tag[i*p[j]] = 1;
|
||||
if (i % p[j] == 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
int n, m;
|
||||
int a[11005], b[11005];
|
||||
int numa[10005], numb[10005];
|
||||
int ans[1000005];
|
||||
int num[1001111];
|
||||
void get(int *x, int n, int *num)
|
||||
{
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
for(int j = 0; j < cnt; j++)
|
||||
{
|
||||
int tn = x[i];
|
||||
if(tn < p[j]) break;
|
||||
while(tn){num[j] += tn / p[j]; tn /= p[j];}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool ok()
|
||||
{
|
||||
for(int i = 0; i < cnt; i++)
|
||||
if(numb[i] > numa[i]) return 0;
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
get_prime();
|
||||
scanf("%d", &T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
|
||||
for(int i = 1; i <= m; i++) scanf("%d", &b[i]);
|
||||
memset(numa, 0, sizeof(numa));
|
||||
memset(numb, 0, sizeof(numb));
|
||||
get(a, n, numa);
|
||||
get(b, m, numb);
|
||||
if(!ok())
|
||||
{
|
||||
printf("-1\n");
|
||||
continue;
|
||||
}
|
||||
for(int i = 0; i < cnt; i++) numa[i] -= numb[i];
|
||||
int tp = 0;
|
||||
memset(num, 0, sizeof(num));
|
||||
while(1)
|
||||
{
|
||||
int low = 2, high = 10006;
|
||||
int can = 0;
|
||||
while(low <= high)
|
||||
{
|
||||
int mid = (low + high) >> 1;
|
||||
int fg = 1;
|
||||
for(int j = 0; j < cnt; j++)
|
||||
{
|
||||
int tn = mid;
|
||||
if(tn < p[j]) break;
|
||||
int sum = 0;
|
||||
while(tn){sum += tn / p[j]; tn /= p[j];}
|
||||
if(sum > numa[j])
|
||||
{
|
||||
fg = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(fg) {low = mid + 1; can = max(can, mid);}
|
||||
else high = mid - 1;
|
||||
}
|
||||
int x = can;
|
||||
if(x == 0) break;
|
||||
ans[tp] = x;
|
||||
int ot = INF;
|
||||
for(int j = 0; j < cnt; j++)
|
||||
{
|
||||
int tn = x;
|
||||
if(tn < p[j]) break;
|
||||
int sum = 0;
|
||||
while(tn){sum += tn / p[j]; tn /= p[j];}
|
||||
if(sum > 0) ot = min(ot, numa[j] / sum);
|
||||
}
|
||||
num[tp] += ot;
|
||||
tp++;
|
||||
for(int j = 0; j < cnt; j++)
|
||||
{
|
||||
int tn = x;
|
||||
if(tn < p[j]) break;
|
||||
int sum = 0;
|
||||
while(tn){sum += tn / p[j]; tn /= p[j];}
|
||||
numa[j] -= ot * sum;
|
||||
}
|
||||
}
|
||||
printf("%d\n", tp);
|
||||
for(int i =0; i < tp; i++) printf("%d %d\n", ans[i], num[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,242 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std ;
|
||||
int num[15] ;
|
||||
int b[10] ;
|
||||
int temp[10] , cnt = 0;
|
||||
int p[10] ;
|
||||
int N ;
|
||||
int s[10] ;
|
||||
int st[10] , ed[10] ;
|
||||
char str[10][3] ;
|
||||
struct card{
|
||||
int a[5] , R;
|
||||
void insert(int list[]){
|
||||
for (int i = 0 ; i < 5 ; i++)
|
||||
b[i] = list[i] ;
|
||||
memset(num,0,sizeof(num));
|
||||
for (int i = 0 ; i < 5 ; i++)
|
||||
num[b[i]]++ ;
|
||||
bool flag = 0 ;
|
||||
for (int i = 0 ; i < 5 ; i++){
|
||||
if (num[b[i]]>1){
|
||||
flag=1;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (flag==0){
|
||||
sort(b,b+5) ;
|
||||
for (int i = 0 ; i < 5 ; i++) a[i] = b[i] ;
|
||||
if (b[0]==2&&b[1]==3)
|
||||
if (b[2]==4&&b[3]==5)
|
||||
if (b[4]==14){
|
||||
b[4] = 1 ;
|
||||
sort(b,b+5);
|
||||
for (int i = 0 ; i < 5 ; i++)
|
||||
a[i] = b[i] ;
|
||||
R = 5;
|
||||
return ;
|
||||
}
|
||||
if (b[0]==b[2]-2 && b[1]==b[2]-1)
|
||||
if (b[3]==b[2]+1 && b[4]==b[2]+2)
|
||||
{
|
||||
R = 5 ;
|
||||
return ;
|
||||
}
|
||||
R = 1 ;
|
||||
return ;
|
||||
}
|
||||
int sum2 = 0 , sum3 = 0 , sum4 = 0 ;
|
||||
for (int i = 2 ; i < 15 ; i++){
|
||||
if (num[i]==2) sum2++ ;
|
||||
if (num[i]==3) sum3++ ;
|
||||
if (num[i]==4) sum4++ ;
|
||||
}
|
||||
if (sum4==1){
|
||||
int pos ;
|
||||
for (int i = 0 ; i < 5 ; i++)
|
||||
if (num[b[i]] != 4)
|
||||
pos = i ;
|
||||
a[0] = b[pos] ;
|
||||
R = 7 ;
|
||||
if (pos != 0){
|
||||
for (int i = 1 ; i < 5 ; i++)
|
||||
a[i] = b[0] ;
|
||||
return ;
|
||||
}
|
||||
if (pos != 1){
|
||||
for (int i = 1 ; i < 5 ; i++)
|
||||
a[i] = b[1];
|
||||
return ;
|
||||
}
|
||||
}
|
||||
if (sum2 == 1 && sum3 == 1){
|
||||
R = 6 ;
|
||||
for (int i = 0 ; i < 5 ; i++){
|
||||
if (num[b[i]] == 3){
|
||||
for (int j = 2 ; j < 5 ; j++)
|
||||
a[j] = b[i] ;
|
||||
}else
|
||||
{
|
||||
for (int j = 0 ; j < 2 ; j++)
|
||||
a[j] = b[i] ;
|
||||
}
|
||||
}
|
||||
return ;
|
||||
}
|
||||
if (sum3 == 1){
|
||||
cnt = 0 ; int pos = -1 ;
|
||||
for (int i = 0 ; i < 5; i++)
|
||||
if (num[b[i]] != 3)
|
||||
temp[cnt++] = b[i] ;
|
||||
else
|
||||
pos = i ;
|
||||
for (int i = 2 ; i < 5; i++)
|
||||
a[i] = b[pos] ;
|
||||
sort(temp,temp+2);
|
||||
for (int i = 0 ; i < 2 ; i++)
|
||||
a[i] = temp[i] ;
|
||||
R = 4 ;
|
||||
return ;
|
||||
}
|
||||
if (sum2 == 1){
|
||||
cnt = 0 ; int pos = -1 ;
|
||||
for (int i = 0 ; i < 5; i++)
|
||||
if (num[b[i]] != 2)
|
||||
temp[cnt++] = b[i] ;
|
||||
else
|
||||
pos = i ;
|
||||
for (int i = 3 ; i < 5; i++)
|
||||
a[i] = b[pos] ;
|
||||
sort(temp,temp+3);
|
||||
for (int i = 0 ; i < 3 ; i++)
|
||||
a[i] = temp[i] ;
|
||||
R = 2 ;
|
||||
return ;
|
||||
}
|
||||
R = 3 ;
|
||||
cnt = 0 ; int pos = -1 ;
|
||||
for (int i = 0 ; i < 5 ; i++)
|
||||
if (num[b[i]] != 1)
|
||||
temp[cnt++] = b[i] ;
|
||||
else
|
||||
pos = i ;
|
||||
a[0] = b[pos] ;
|
||||
sort(temp,temp+4);
|
||||
for (int i = 1 ; i < 5 ; i++)
|
||||
a[i] = temp[i-1];
|
||||
}
|
||||
}state[15*15*15*15*15] ;
|
||||
void check(){
|
||||
if (p[0]==p[1] && p[0]==p[2])
|
||||
if (p[0]==p[3] && p[0]==p[4])
|
||||
return ;
|
||||
state[++N].insert(p) ;
|
||||
}
|
||||
void dfs(int i){
|
||||
if (i > 4){
|
||||
check() ;
|
||||
return ;
|
||||
}
|
||||
for (int j = 2 ; j < 15 ; j++)
|
||||
{
|
||||
p[i] = j ;
|
||||
dfs(i+1) ;
|
||||
}
|
||||
}
|
||||
int get(char c){
|
||||
if (c>='0' && c<='9') return c - '0' ;
|
||||
if (c=='T') return 10 ;
|
||||
if (c=='J') return 11 ;
|
||||
if (c=='Q') return 12 ;
|
||||
if (c=='K') return 13 ;
|
||||
if (c=='A') return 14 ;
|
||||
}
|
||||
int Cmp(card &A , card &B){
|
||||
if (A.R < B.R) return -1 ;
|
||||
if (A.R > B.R) return 1 ;
|
||||
for (int i = 4 ; i >= 0 ; i--){
|
||||
if (A.a[i] < B.a[i])
|
||||
return -1 ;
|
||||
if (A.a[i] > B.a[i])
|
||||
return 1 ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
bool cmp(const card &A , const card &B){
|
||||
if (A.R != B.R) return A.R < B.R ;
|
||||
for (int i = 4 ; i > 0 ; i--)
|
||||
if (A.a[i] != B.a[i])
|
||||
return A.a[i] < B.a[i];
|
||||
return A.a[0] < B.a[0] ;
|
||||
}
|
||||
int search(int L,int R,card A){
|
||||
int ret ;
|
||||
while (L<=R){
|
||||
int mid = (L+R)>>1 ;
|
||||
if (Cmp(state[mid],A)>=0){
|
||||
R = mid - 1 ;
|
||||
ret = mid ;
|
||||
}else
|
||||
L = mid + 1 ;
|
||||
}
|
||||
return ret ;
|
||||
}
|
||||
int main(){
|
||||
N = 0 ;
|
||||
dfs(0) ;
|
||||
sort(state+1,state+N+1,cmp);
|
||||
int cnt = 1 ;
|
||||
for (int i = 2 ; i <= N ; i++){
|
||||
if (Cmp(state[i],state[i-1])==0) continue ;
|
||||
state[++cnt] = state[i] ;
|
||||
}
|
||||
N = cnt ; memset(s,0,sizeof(s));
|
||||
memset(st,0,sizeof(st));
|
||||
for (int i = 1 ; i <= N ; i++){
|
||||
s[state[i].R]++ ;
|
||||
if (st[state[i].R]==0) st[state[i].R]=i ;
|
||||
ed[state[i].R] = i ;
|
||||
}
|
||||
int Q ;
|
||||
scanf("%d",&Q) ;
|
||||
int sum[10];
|
||||
sum[0] = 0 ;
|
||||
for (int i = 1 ; i <= 5 ; i++)
|
||||
sum[i] = sum[i-1] + s[i] ;
|
||||
while (Q--){
|
||||
for (int j = 0 ; j < 5 ; j++)
|
||||
scanf("%s",str[j]);
|
||||
card now ;
|
||||
for (int j = 0 ; j < 5 ; j++)
|
||||
b[j] = get(str[j][0]);
|
||||
now.insert(b);
|
||||
bool samesuit = true ;
|
||||
for (int j = 1 ; j < 5 ; j++)
|
||||
if (str[j][1] != str[0][1]) samesuit = false ;
|
||||
int rank = now.R ;
|
||||
int pos = search(st[rank],ed[rank],now) - st[rank] + 1;
|
||||
int Tonghua = s[1] ;
|
||||
if (!samesuit){
|
||||
if (rank <= 5){
|
||||
printf("%d\n",sum[rank-1] + pos) ;
|
||||
}
|
||||
else{
|
||||
if (rank == 6)
|
||||
printf("%d\n",sum[5] + Tonghua + pos);
|
||||
else
|
||||
printf("%d\n",sum[5] + Tonghua + s[6] + pos) ;
|
||||
}
|
||||
}else
|
||||
{
|
||||
if (rank == 5){
|
||||
printf("%d\n",sum[5] + Tonghua + s[6] + s[7] + pos) ;
|
||||
}
|
||||
else
|
||||
printf("%d\n",sum[5] + pos);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
const int maxn = 100005;
|
||||
const int maxm = 400005;
|
||||
const int inf = 1000000005;
|
||||
int head[maxn], vert[maxm], colo[maxm], noxt[maxm], cunt;
|
||||
int sdis[maxn], edis[maxn], path[maxn], leng;
|
||||
int queue[maxn], qhead, qtail;
|
||||
bool vis[maxn], rit[maxn];
|
||||
void init(int n)
|
||||
{
|
||||
cunt = 0;
|
||||
for (int i = 0; i <= n; i++)
|
||||
{
|
||||
head[i] = -1;
|
||||
sdis[i] = -1;
|
||||
edis[i] = -1;
|
||||
vis[i] = 0;
|
||||
rit[i] = 0;
|
||||
path[i] = inf;
|
||||
}
|
||||
}
|
||||
void addedge(int x, int y, int c)
|
||||
{
|
||||
vert[cunt] = y;
|
||||
colo[cunt] = c;
|
||||
noxt[cunt] = head[x];
|
||||
head[x] = cunt++;
|
||||
}
|
||||
void BFS(int start, int *dis)
|
||||
{
|
||||
dis[start] = 0;
|
||||
qhead = qtail = 0;
|
||||
queue[qtail++] = start;
|
||||
while (qhead < qtail)
|
||||
{
|
||||
int x = queue[qhead++];
|
||||
for (int p = head[x]; p != -1; p = noxt[p])
|
||||
{
|
||||
int y = vert[p];
|
||||
if (-1 == dis[y])
|
||||
{
|
||||
dis[y] = dis[x] + 1;
|
||||
queue[qtail++] = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void IdeadPath()
|
||||
{
|
||||
qhead = qtail = 0;
|
||||
queue[qtail++] = 1;
|
||||
int step = 0;
|
||||
while (qhead < qtail)
|
||||
{
|
||||
int ttail = qtail;
|
||||
while (qhead < ttail)
|
||||
{
|
||||
int x = queue[qhead++];
|
||||
for (int p = head[x]; p != -1; p = noxt[p])
|
||||
{
|
||||
int y = vert[p];
|
||||
int c = colo[p];
|
||||
if (rit[y] && sdis[y] == step + 1)
|
||||
{
|
||||
if (c < path[step])
|
||||
{
|
||||
path[step] = c;
|
||||
for (int i = ttail; i < qtail; i++)
|
||||
vis[queue[i]] = 0;
|
||||
qtail = ttail;
|
||||
vis[y] = 1;
|
||||
queue[qtail++] = y;
|
||||
}
|
||||
else if (c == path[step] && !vis[y])
|
||||
{
|
||||
vis[y] = 1;
|
||||
queue[qtail++] = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
step++;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int test, cas;
|
||||
int n, m, a, b, c;
|
||||
scanf("%d", &test);
|
||||
for (cas = 1; cas <= test; cas++)
|
||||
{
|
||||
scanf("%d %d", &n, &m);
|
||||
init(n);
|
||||
for (int i = 0; i < m; i++)
|
||||
{
|
||||
scanf("%d %d %d", &a, &b, &c);
|
||||
if (a == b) continue;
|
||||
addedge(a, b, c);
|
||||
addedge(b, a, c);
|
||||
}
|
||||
BFS(1, sdis);
|
||||
BFS(n, edis);
|
||||
leng = sdis[n];
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
if (sdis[i] + edis[i] == leng)
|
||||
rit[i] = 1;
|
||||
}
|
||||
IdeadPath();
|
||||
printf("%d\n", leng);
|
||||
for (int i = 0; i < leng; i++)
|
||||
{
|
||||
if (i) printf(" ");
|
||||
printf("%d", path[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cmath>
|
||||
#define eps 1e-10
|
||||
#define N 50005
|
||||
#define zero(a) (fabs(a)<eps)
|
||||
using namespace std;
|
||||
struct Point {
|
||||
double x,y;
|
||||
Point(){}
|
||||
Point(double tx,double ty){x=tx;y=ty;}
|
||||
}p[N],q[N];
|
||||
int n,m;
|
||||
struct Segment{
|
||||
Point s,e;
|
||||
double angle;
|
||||
void get_angle(){angle=atan2(e.y-s.y,e.x-s.x);}
|
||||
}seg[N];
|
||||
double xmul(Point p0,Point p1,Point p2){
|
||||
return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
|
||||
}
|
||||
double Get_Area(Point pt[],int n){
|
||||
double area=0;
|
||||
for(int i=1;i<n-1;i++)
|
||||
area+=xmul(pt[0],pt[i],pt[i+1]);
|
||||
return fabs(area)/2;
|
||||
}
|
||||
Point Get_Intersect(Segment s1,Segment s2){
|
||||
double u=xmul(s1.s,s1.e,s2.s),v=xmul(s1.e,s1.s,s2.e);
|
||||
Point t;
|
||||
t.x=(s2.s.x*v+s2.e.x*u)/(u+v);t.y=(s2.s.y*v+s2.e.y*u)/(u+v);
|
||||
return t;
|
||||
}
|
||||
void HalfPlaneIntersect(Segment seg[],int n){
|
||||
int idx;
|
||||
for(int i=0;i<n;i++)
|
||||
if(seg[i].angle+eps<seg[(i+1)%n].angle&&seg[i].angle+eps<seg[(i-1+n)%n].angle){
|
||||
idx=i;
|
||||
break;
|
||||
}
|
||||
Segment deq[N];
|
||||
deq[0]=seg[idx];deq[1]=seg[(idx+1)%n];
|
||||
int head=0,tail=1;
|
||||
idx=(idx+2)%n;
|
||||
for(int i=2;i<n;i++,idx=(idx+1)%n){
|
||||
while(head<tail&&xmul(seg[idx].s,seg[idx].e,Get_Intersect(deq[tail],deq[tail-1]))<-eps) tail--;
|
||||
while(head<tail&&xmul(seg[idx].s,seg[idx].e,Get_Intersect(deq[head],deq[head+1]))<-eps) head++;
|
||||
deq[++tail]=seg[idx];
|
||||
}
|
||||
while(head<tail&&xmul(deq[head].s,deq[head].e,Get_Intersect(deq[tail],deq[tail-1]))<-eps) tail--;
|
||||
while(head<tail&&xmul(deq[tail].s,deq[tail].e,Get_Intersect(deq[head],deq[head+1]))<-eps) head++;
|
||||
m=0;
|
||||
if(tail==head) return;
|
||||
for(int i=head;i<tail;i++){
|
||||
q[m++]=Get_Intersect(deq[i],deq[i+1]);
|
||||
}
|
||||
if(tail>head+1)
|
||||
q[m++]=Get_Intersect(deq[head],deq[tail]);
|
||||
}
|
||||
int slove(int mid){
|
||||
if(n-mid<=2) return 1;
|
||||
for(int i=0;i<n;i++){
|
||||
seg[i].s=p[i];
|
||||
seg[i].e=p[(i+mid+1)%n];
|
||||
seg[i].get_angle();
|
||||
}
|
||||
HalfPlaneIntersect(seg,n);
|
||||
return zero(Get_Area(q,m));
|
||||
}
|
||||
int main(){
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
for(int i=1;i<=n/2;i++) swap(p[i],p[n-i]);
|
||||
int ans,low=0,high=n,mid;
|
||||
while(low<=high){
|
||||
mid=(low+high)/2;
|
||||
if(slove(mid)){ans=mid;high=mid-1;}
|
||||
else low=mid+1;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
int s[1000005];
|
||||
int bin(int x,int n)
|
||||
{
|
||||
int l,h,m;
|
||||
l = 0;
|
||||
h = n-1;
|
||||
m = (l+h/2);
|
||||
while(l<=h)
|
||||
{
|
||||
m = (l+h)/2;
|
||||
if(x<s[m])
|
||||
h = m-1;
|
||||
else if(x>s[m])
|
||||
l = m+1;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,i,j,a;
|
||||
while(~scanf("%d%d",&n,&m),n+m)
|
||||
{
|
||||
for(i = 0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&s[i]);
|
||||
}
|
||||
int cnt = 0;
|
||||
for(i = 0;i<m;i++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
cnt+=bin(a,n);
|
||||
}
|
||||
printf("%d\n",cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#define MAX 1500
|
||||
int a[MAX], n;
|
||||
int main(void)
|
||||
{
|
||||
while(scanf("%d", &n) && n)
|
||||
{
|
||||
int i, j;
|
||||
a[0] = 0;
|
||||
for(i = 1; i <= n; i++)
|
||||
scanf("%d", &a[i]);
|
||||
a[n+1] = 1422;
|
||||
n = n + 2;
|
||||
sort(a, a + n);
|
||||
int flag = 0;
|
||||
for(i = 0; i + 1 < n; i++)
|
||||
{
|
||||
if(a[i+1] - a[i] > 200)
|
||||
flag = 1;
|
||||
}
|
||||
if(a[n - 1] - a[n-2] > 100) flag = 1;
|
||||
if(flag == 1)
|
||||
puts("IMPOSSIBLE");
|
||||
else puts("POSSIBLE");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
int a[200];
|
||||
int n;
|
||||
int ans;
|
||||
int sum[200];
|
||||
void Divide(int p,int differ,int hav)
|
||||
{
|
||||
int i,j,n;
|
||||
if (differ==0)
|
||||
{
|
||||
if (hav>ans) ans=hav;
|
||||
}
|
||||
if (p<0) return;
|
||||
if (abs(differ)>sum[p]) return;
|
||||
if (sum[p]+hav<ans) return;
|
||||
Divide(p-1,differ+a[p],hav+a[p]);
|
||||
Divide(p-1,differ-a[p],hav+a[p]);
|
||||
Divide(p-1,differ,hav);
|
||||
}
|
||||
int Solve()
|
||||
{
|
||||
ans=0;
|
||||
Divide(n-1,0,0);
|
||||
return sum[n-1]-ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(1)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
if (n==0) break;
|
||||
for (i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
if (i==0) sum[i]=a[i];
|
||||
else sum[i]=sum[i-1]+a[i];
|
||||
}
|
||||
printf("%d\n",Solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int main()
|
||||
{
|
||||
char c[20];
|
||||
while(scanf("%s",c),c[0]!='E')
|
||||
{
|
||||
int x=0,y,flag=1;
|
||||
int k;
|
||||
for(int i=0;c[i];i++)
|
||||
{
|
||||
if(c[i]=='-'&&i==0)
|
||||
flag=-1;
|
||||
else
|
||||
x=x*10+c[i]-48;
|
||||
}
|
||||
x=x*flag;
|
||||
scanf("%d",&y);
|
||||
if(x<0)
|
||||
x=-x;
|
||||
if(y<0)
|
||||
y=-y;
|
||||
if(y<x) {k=x;x=y;y=k;}
|
||||
if(y<=2*x)
|
||||
{
|
||||
if(x==1&&y==1)
|
||||
printf("2\n");
|
||||
else if(x==2&&y==2)
|
||||
printf("4\n");
|
||||
else
|
||||
printf("%d\n",(x+y)/3+(x+y)%3);
|
||||
}
|
||||
else
|
||||
{
|
||||
int ans=x;
|
||||
int c=(y-2*x)%4;
|
||||
ans+=c;
|
||||
ans+=(y-2*x-c)/2;
|
||||
if(y==1&&x==0)
|
||||
ans=3;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
#include <iomanip>
|
||||
#include <math.h>
|
||||
using namespace std;
|
||||
struct dot{
|
||||
double x, y, r;
|
||||
}all[1024];
|
||||
int n, vis[1024], ok;
|
||||
double in, out;
|
||||
void DFS(int u)
|
||||
{
|
||||
if(!ok) return;
|
||||
vis[u] = 1;
|
||||
if(all[u].y - all[u].r <= 0) {ok = 0; return;}
|
||||
for(int v = 0; v < n; ++v)
|
||||
if(!vis[v] && hypot(all[u].x - all[v].x, all[u].y - all[v].y) < all[u].r + all[v].r)
|
||||
DFS(v);
|
||||
if(all[u].x - all[u].r <= 0)
|
||||
in = min(in, all[u].y - sqrt(all[u].r * all[u].r - all[u].x * all[u].x));
|
||||
if(all[u].x + all[u].r >= 1000)
|
||||
out = min(out, all[u].y - sqrt(all[u].r * all[u].r - (1000-all[u].x) * (1000-all[u].x)));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
while(memset(vis, 0, sizeof(vis)), ok = 1, in = out = 1000, cin >> n){
|
||||
for(int i = 0; i < n; ++i)
|
||||
cin >> all[i].x >> all[i].y >> all[i].r;
|
||||
for(int i = 0; i < n; ++i)
|
||||
if(!vis[i] && all[i].y + all[i].r >= 1000)
|
||||
DFS(i);
|
||||
if(!ok) puts("IMPOSSIBLE");
|
||||
else printf("%.2f %.2f %.2f %.2f\n", 0.0, in, 1000.0, out);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
using namespace std ;
|
||||
const int maxn = 100010 ;
|
||||
const int inf = 0x3f3f3f3f ;
|
||||
struct Edge
|
||||
{
|
||||
int v ;int w ;
|
||||
int next ;
|
||||
}edge[maxn*10] ;
|
||||
int head[maxn] ;
|
||||
int dis[20][maxn] ;
|
||||
int vis[maxn] ;
|
||||
int nedge ;int a[maxn] ,num;
|
||||
int n , m ;
|
||||
void addedge(int u , int v , int w)
|
||||
{
|
||||
edge[nedge].v = v ;
|
||||
edge[nedge].w = w ;
|
||||
edge[nedge].next = head[u] ;
|
||||
head[u] = nedge++ ;
|
||||
}
|
||||
void spfa(int st)
|
||||
{
|
||||
queue<int> que ;
|
||||
memset(vis , 0 ,sizeof(vis)) ;
|
||||
for(int i = 0;i < n;i++)
|
||||
dis[st][i] = i == a[st] ? 0 : inf ;
|
||||
que.push(a[st]) ;
|
||||
vis[a[st]] = 1;
|
||||
while(que.size())
|
||||
{
|
||||
int u = que.front() ;
|
||||
que.pop() ;
|
||||
vis[u] = 0 ;
|
||||
for(int i = head[u] ; i != -1 ;i = edge[i].next)
|
||||
{
|
||||
int v = edge[i].v ;
|
||||
if(dis[st][v] > dis[st][u] + edge[i].w)
|
||||
{
|
||||
dis[st][v] = dis[st][u] + edge[i].w ;
|
||||
if(!vis[v])
|
||||
vis[v] = 1 , que.push(v) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans = inf ;
|
||||
void dfs(int pos , int sum , int step)
|
||||
{
|
||||
if(step == num)
|
||||
{
|
||||
ans = min(ans , sum + dis[pos][0]) ;
|
||||
return ;
|
||||
}
|
||||
for(int i = 1;i <= num;i++)
|
||||
if(vis[a[i]])continue ;
|
||||
else
|
||||
{
|
||||
vis[a[i]] = 1;
|
||||
dfs(i , sum + dis[pos][a[i]] , step + 1) ;
|
||||
vis[a[i]] = 0 ;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t ;
|
||||
scanf("%d" ,&t) ;
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d" , &n , &m) ;
|
||||
memset(head , -1 , sizeof(head)) ;
|
||||
nedge = 0 ;
|
||||
while(m--)
|
||||
{
|
||||
int u , v , w ;
|
||||
scanf("%d%d%d" , &u , &v ,&w) ;
|
||||
addedge(u , v , w) ;
|
||||
addedge(v , u , w) ;
|
||||
}
|
||||
scanf("%d" , &num) ;
|
||||
spfa(0) ;
|
||||
for(int i = 1;i <= num ; i++)
|
||||
scanf("%d" , &a[i]) , spfa(i) ;
|
||||
ans = inf ;
|
||||
memset(vis , 0 ,sizeof(vis)) ;
|
||||
dfs(0 , 0 , 0) ;
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
#include<iostream>
|
||||
#include<cmath>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
const double eps=1e-10;
|
||||
const double PI=acos(-1);
|
||||
int dcmp(double x)
|
||||
{
|
||||
return (x>eps)-(x<-eps);
|
||||
}
|
||||
struct Point3
|
||||
{
|
||||
double x,y,z;
|
||||
Point3(double x=0,double y=0,double z=0):x(x),y(y),z(z) {}
|
||||
};
|
||||
typedef Point3 Vector3;
|
||||
Vector3 operator+(Point3 A,Point3 B)
|
||||
{
|
||||
return Point3(A.x+B.x,A.y+B.y,A.z+B.z);
|
||||
}
|
||||
Vector3 operator-(Point3 A,Point3 B)
|
||||
{
|
||||
return Point3(A.x-B.x,A.y-B.y,A.z-B.z);
|
||||
}
|
||||
Vector3 operator*(Point3 A,double p)
|
||||
{
|
||||
return Point3(A.x*p,A.y*p,A.z*p);
|
||||
}
|
||||
Vector3 operator/(Point3 A,double p)
|
||||
{
|
||||
return Point3(A.x/p,A.y/p,A.z/p);
|
||||
}
|
||||
bool operator<(Point3 &A,Point3 &B)
|
||||
{
|
||||
return A.x<B.x||(A.x==B.x&&A.y<B.y)||(A.x==B.x&&A.y==B.y&&A.z<B.z);
|
||||
}
|
||||
bool operator==(Point3 &A,Point3 &B)
|
||||
{
|
||||
return dcmp(A.x-B.x)==0&&dcmp(A.y-B.y)==0&&dcmp(A.z-B.z)==0;
|
||||
}
|
||||
ostream & operator<<(ostream & out,Vector3 A)
|
||||
{
|
||||
out<<A.x<<' '<<A.y<<' '<<A.z<<endl;
|
||||
return out;
|
||||
}
|
||||
double Dot(Vector3 A,Vector3 B)
|
||||
{
|
||||
return A.x*B.x+A.y*B.y+A.z*B.z;
|
||||
}
|
||||
double Length(Vector3 A)
|
||||
{
|
||||
return sqrt(Dot(A,A));
|
||||
}
|
||||
double Angle(Vector3 A,Vector3 B)
|
||||
{
|
||||
return acos(Dot(A,B)/Length(A)/Length(B));
|
||||
}
|
||||
Vector3 Cross(Vector3 A,Vector3 B)
|
||||
{
|
||||
return Vector3(A.y*B.z-A.z*B.y,A.x*B.z-A.z*B.x,A.x*B.y-A.y*B.x);
|
||||
}
|
||||
double Area2(Point3 A,Point3 B,Point3 C)
|
||||
{
|
||||
return Length(Cross(B-A,C-A));
|
||||
}
|
||||
int nearest(double p)
|
||||
{
|
||||
int a=floor(p);
|
||||
int b=ceil(p);
|
||||
if(b-p>=p-a) return b;
|
||||
else return a;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
cin>>T;
|
||||
double a1,b1,a2,b2;
|
||||
double R=6371009;
|
||||
double x1,y1,z1,x2,y2,z2;
|
||||
while(T--)
|
||||
{
|
||||
cin>>b1>>a1>>b2>>a2;
|
||||
b1=b1/180.0*PI;
|
||||
a1=a1/180.0*PI;
|
||||
b2=b2/180.0*PI;
|
||||
a2=a2/180.0*PI;
|
||||
x1=R*cos(b1)*cos(a1);
|
||||
y1=R*cos(b1)*sin(a1);
|
||||
z1=R*sin(b1);
|
||||
x2=R*cos(b2)*cos(a2);
|
||||
y2=R*cos(b2)*sin(a2);
|
||||
z2=R*sin(b2);
|
||||
Point3 A=Point3(x1,y1,z1);
|
||||
Point3 B=Point3(x2,y2,z2);
|
||||
double real_dist=Length(A-B);
|
||||
Point3 P;
|
||||
double arc_dist=Angle(A-P, B-P)*R;
|
||||
printf("%.0lf\n",arc_dist-real_dist);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include"stdio.h"
|
||||
int judge(int x,int sum,int max)
|
||||
{
|
||||
if(sum*2>x) return 0;
|
||||
return x/max+1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int p[111],max,sum;
|
||||
int i;
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
max=0;
|
||||
sum=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&p[i]);
|
||||
sum+=p[i];
|
||||
if(p[i]>max) max=p[i];
|
||||
}
|
||||
printf("%d ",judge(50,sum,max));
|
||||
printf("%d ",judge(60,sum,max));
|
||||
printf("%d\n",judge(70,sum,max));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
char str[1000005];
|
||||
int drow[8]={0,-1,-1,-1,0,1,1,1};
|
||||
int dcol[8]={1,1,0,-1,-1,-1,0,1};
|
||||
int main()
|
||||
{
|
||||
__int64 r1,c1,val,r,c,i,j,n;
|
||||
__int64 s,ans;
|
||||
while(scanf("%s",str)!=EOF)
|
||||
{
|
||||
n=strlen(str);
|
||||
r=c=s=0;
|
||||
for (i=0;i<n;i++)
|
||||
{
|
||||
val=str[i]-'0';
|
||||
r1=r+drow[val];
|
||||
c1=c+dcol[val];
|
||||
s=s+r*c1-c*r1;
|
||||
r=r1;
|
||||
c=c1;
|
||||
}
|
||||
if (s<0) s=-s;
|
||||
printf("%I64d\n",(n+s)/2+1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include <iostream>
|
||||
#include<cctype>
|
||||
#include<string>
|
||||
#include<cstdio>
|
||||
#include<sstream>
|
||||
using namespace std;
|
||||
#define MAXN 110000
|
||||
#define INF 10000000
|
||||
int d[MAXN], u[MAXN], v[MAXN], w[MAXN], num[10];
|
||||
int n, m, e, ve, vMax, vMin;
|
||||
string input, s;
|
||||
int ballman_ford()
|
||||
{
|
||||
for(int i = 0; i <= n; d[i++] = INF);
|
||||
d[0] = 0;
|
||||
for(int i = 0; i < n; i++){
|
||||
for(int j = 0; j < ve; j++)
|
||||
if(d[v[j]] > d[u[j]] + w[j])
|
||||
d[v[j]] = d[u[j]] + w[j];
|
||||
}
|
||||
for(int j = 0; j <= ve; j++)
|
||||
if(d[v[j]] > d[u[j]] + w[j])
|
||||
return 0;
|
||||
for(int j = 1; j <= n; j++){
|
||||
if(vMin > d[j]) vMin = d[j];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i, j, k, l, flag;
|
||||
while(cin>>n){
|
||||
if(!n) break;
|
||||
cin>>m;
|
||||
getchar();
|
||||
e = 0;
|
||||
for(i = 0; i < m; i++){
|
||||
getline(cin, input);
|
||||
istringstream in(input);
|
||||
num[0] = num[1] =num[2] = 0;
|
||||
for(j = 0, l = 0; in>>s; j++){
|
||||
if(isdigit(s[0])){
|
||||
for(k = 0; k < s.size(); k++)
|
||||
num[l] = num[l] * 10 + s[k] - '0';
|
||||
l++;
|
||||
}
|
||||
if(j == 3){
|
||||
if(s == "at") flag = 1;
|
||||
else flag = 0;
|
||||
}
|
||||
}
|
||||
if(flag){
|
||||
u[e] = num[0]; v[e] = num[2]; w[e++] = -num[1];
|
||||
}else {
|
||||
u[e] = num[0]; v[e] = num[2]; w[e++] = 0;
|
||||
u[e] = num[2]; v[e] = num[0]; w[e++] = num[1];
|
||||
}
|
||||
}
|
||||
for(i = 1, ve = e; i <= n; i++, ve++){
|
||||
u[ve] = 0; v[ve] = i; w[ve] = 0;
|
||||
}
|
||||
vMin = 1 << 30;
|
||||
if(ballman_ford()){
|
||||
int minv = 1 << 30;
|
||||
for (int i = 1; i <= n; i++) {
|
||||
if (minv > d[i] - vMin)
|
||||
minv = d[i] - vMin;
|
||||
}
|
||||
if (minv == 0) {
|
||||
for (int i = 1; i <= n; i++) {
|
||||
printf("%d", d[i] - vMin + 1);
|
||||
if (i != n) {
|
||||
printf(
|
||||
" ");
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
} else {
|
||||
for (int i = 1; i <= n; i++) {
|
||||
printf("%d", d[i] - vMin);
|
||||
if (i != n) {
|
||||
printf(
|
||||
" ");
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}else printf("Impossible.\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct Page
|
||||
{
|
||||
int l,r;
|
||||
};
|
||||
bool cmp(Page a,Page b)
|
||||
{
|
||||
if(a.l == b.l)return a.r < b.r;
|
||||
return a.l < b.l;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d", &n), n)
|
||||
{
|
||||
char str[1005]= {0},word[1005]= {0};
|
||||
Page p[1005];
|
||||
getchar();
|
||||
gets(str);
|
||||
int L=strlen(str);
|
||||
int pos=0,nn=0;
|
||||
for(int i=0; i<L; ++i)
|
||||
{
|
||||
if(str[i]==','||i==L-1)
|
||||
{
|
||||
if(i==L-1) word[pos++]=str[i];
|
||||
int l=strlen(word);
|
||||
int a=0,b=0;
|
||||
bool pp=false;
|
||||
for(int j=0; j<l; ++j)
|
||||
{
|
||||
if(!pp&&word[j]!='-')
|
||||
a=a*10+word[j]-'0';
|
||||
if(word[j]=='-')
|
||||
pp=true;
|
||||
else if(pp==true)
|
||||
b=b*10+word[j]-'0';
|
||||
}
|
||||
if(b==0) b=a;
|
||||
if(b>n) b=n;
|
||||
if(a<=b)
|
||||
{
|
||||
p[nn].l=a;
|
||||
p[nn].r=b;
|
||||
nn++;
|
||||
}
|
||||
memset(word,0,sizeof(word));
|
||||
pos=0;
|
||||
}
|
||||
else
|
||||
word[pos++]=str[i];
|
||||
}
|
||||
sort(p,p+nn,cmp);
|
||||
int mx=p[0].r,ans=0;
|
||||
if(nn) ans+=p[0].r-p[0].l+1;
|
||||
for(int i=1;i<nn;++i)
|
||||
{
|
||||
if(p[i].r<=mx) continue;
|
||||
if(p[i].l>mx)
|
||||
{
|
||||
ans+=p[i].r-p[i].l+1;
|
||||
mx=p[i].r;
|
||||
}
|
||||
else if(p[i].r>mx)
|
||||
{
|
||||
ans+=p[i].r-mx;
|
||||
mx=p[i].r;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,146 @@
|
|||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
using std::sort;
|
||||
struct dat
|
||||
{
|
||||
int socer;
|
||||
int top;
|
||||
int low;
|
||||
int number;
|
||||
bool operator<(const dat p)const
|
||||
{
|
||||
return p.socer<socer;
|
||||
}
|
||||
} a[33],b[33];
|
||||
char name[33][33];
|
||||
struct odat
|
||||
{
|
||||
int as;
|
||||
int bs;
|
||||
} vs[20];
|
||||
int n,m;
|
||||
int aa,bb,q;
|
||||
int fins(char *s)
|
||||
{
|
||||
for(int i=0; i<n; i++)
|
||||
if(!strcmp(name[i],s))
|
||||
return i;
|
||||
return 0;
|
||||
}
|
||||
bool cmp(dat p, dat q)
|
||||
{
|
||||
return p.socer>q.socer;
|
||||
}
|
||||
int ans[33];
|
||||
void dfs(int x)
|
||||
{
|
||||
if(x==q)
|
||||
{
|
||||
for(int i=0; i<n; i++)
|
||||
b[i]=a[i];
|
||||
for(int i=0; i<q; i++)
|
||||
{
|
||||
int nx=vs[i].as;
|
||||
int ny=vs[i].bs;
|
||||
if(ans[i]==-1)
|
||||
{
|
||||
b[nx].socer+=3;
|
||||
}
|
||||
else if(ans[i]==0)
|
||||
{
|
||||
b[nx].socer++;
|
||||
b[ny].socer++;
|
||||
}
|
||||
else
|
||||
{
|
||||
b[ny].socer+=3;
|
||||
}
|
||||
}
|
||||
sort(b, b+n);
|
||||
int pp=1,dd=0;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
dd++;
|
||||
if(b[i-1].socer!=b[i].socer && i)
|
||||
pp=dd;
|
||||
if(b[i].top>pp)
|
||||
b[i].top=pp;
|
||||
if(b[i].low<pp)
|
||||
b[i].low=pp;
|
||||
}
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
int nx=b[i].number;
|
||||
a[nx].low=b[i].low;
|
||||
a[nx].top=b[i].top;
|
||||
}
|
||||
}
|
||||
else
|
||||
for(int i=-1; i<2; i++)
|
||||
ans[x]=i,dfs(x+1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int count=0;
|
||||
while(scanf("%d %d",&n,&m)==2 && (n+m))
|
||||
{
|
||||
if(count)puts("");
|
||||
count=1;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
scanf("%s",name[i]);
|
||||
a[i].socer=0;
|
||||
a[i].number=i;
|
||||
a[i].top=n+1;
|
||||
a[i].low=0;
|
||||
}
|
||||
char s[33],s2[33];
|
||||
q=0;
|
||||
for(int i=0; i<m; i++)
|
||||
{
|
||||
scanf("%s vs %s%d %d",s,s2,&aa,&bb);
|
||||
s2[strlen(s2)-1]='\0';
|
||||
int x=fins(s);
|
||||
int y=fins(s2);
|
||||
if(aa==-1 && bb==-1)
|
||||
{
|
||||
vs[q].as=x;
|
||||
vs[q++].bs=y;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(aa>bb)
|
||||
a[x].socer+=3;
|
||||
else if(bb>aa)
|
||||
a[y].socer+=3;
|
||||
else if(aa==bb)
|
||||
a[y].socer++,a[x].socer++;
|
||||
}
|
||||
}
|
||||
dfs(0);
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
printf("Team %s can finish as high as ",name[i]);
|
||||
if(a[i].top==1)
|
||||
printf("1st");
|
||||
else if(a[i].top==2)
|
||||
printf("2nd");
|
||||
else if(a[i].top==3)
|
||||
printf("3rd");
|
||||
else
|
||||
printf("%dth",a[i].top);
|
||||
printf(" place and as low as ");
|
||||
if(a[i].low==1)
|
||||
printf("1st");
|
||||
else if(a[i].low==2)
|
||||
printf("2nd");
|
||||
else if(a[i].low==3)
|
||||
printf("3rd");
|
||||
else
|
||||
printf("%dth",a[i].low);
|
||||
printf(" place.\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <iostream>
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
#define N 1005
|
||||
bool ans[N][N];
|
||||
int str1[N],str2[N],str3[N*2];
|
||||
int n,m,t;
|
||||
void solve(int n1,int n2)
|
||||
{
|
||||
if(n1>n||n2>m) return ;
|
||||
if(n1==n&&n2==m)
|
||||
{
|
||||
ans[n1][n2]=1; return ;
|
||||
}
|
||||
if(ans[n1][n2]) return ;
|
||||
ans[n1][n2]=1;
|
||||
if(str3[n1+n2+1]==str1[n1+1]&&!ans[n][n])
|
||||
solve(n1+1,n2);
|
||||
if(str3[n1+n2+1]==str2[n2+1]&&!ans[n][n])
|
||||
solve(n1,n2+1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
while(scanf("%d%d",&n,&m),n&&m)
|
||||
{
|
||||
for(i=1;i<=n;i++) scanf("%d",&str1[i]);
|
||||
for(i=1;i<=m;i++) scanf("%d",&str2[i]);
|
||||
for(i=1;i<=n+m;i++) scanf("%d",&str3[i]);
|
||||
memset(ans,0,sizeof(ans));
|
||||
solve(0,0);
|
||||
if(ans[n][m]) puts("possible");
|
||||
else puts("not possible");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const double E = 1e-12;
|
||||
inline
|
||||
int dblcmp(double x)
|
||||
{
|
||||
if (x > - E && x < E)
|
||||
return 0;
|
||||
return x > 0 ? 1 : -1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
double num[5];
|
||||
while (true) {
|
||||
int cc = 0;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
scanf("%lf", &num[i]);
|
||||
if (dblcmp(num[i]) == 0)
|
||||
cc++;
|
||||
}
|
||||
if (cc == 3) {
|
||||
break;
|
||||
}
|
||||
sort(num, num + 3);
|
||||
double t = num[0];
|
||||
long long h = floor(num[1] + 0.5), l = floor(num[2] + 0.5);
|
||||
bool ok = false;
|
||||
if (dblcmp(t - 0.25) >= 0 && h >= 90 && l >= 125) {
|
||||
if (dblcmp(7 - t) >= 0 && h <= 155 && l <= 290) {
|
||||
printf("letter\n");
|
||||
ok = true;
|
||||
} else {
|
||||
if (dblcmp(50 - t) >= 0 && h <= 300 && l <= 380) {
|
||||
printf("packet\n");
|
||||
ok = true;
|
||||
} else {
|
||||
double ans = t * 2 + (double)h * 2 + (double)l;
|
||||
if (dblcmp(ans - 2100) <= 0) {
|
||||
printf("parcel\n");
|
||||
ok = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!ok) {
|
||||
printf("not mailable\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
#include <stdio.h>
|
||||
#include <string>
|
||||
#include <string.h>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
string num[1001] = {"", "first", "second", "third", "fourth", "fifth", "sixth", "seventh",
|
||||
"eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth",
|
||||
"fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth", "twentieth"
|
||||
};
|
||||
string t[1001] = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
|
||||
"eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
|
||||
"twenty"
|
||||
};
|
||||
string retNum(int val) {
|
||||
string res;
|
||||
if(val >= 100) {
|
||||
res += t[val / 100] + t[100];
|
||||
val %= 100;
|
||||
}
|
||||
if(val >= 20) {
|
||||
res += t[val / 10 * 10];
|
||||
if(val % 10 != 0) res += t[val % 10];
|
||||
return res;
|
||||
}
|
||||
return res + t[val];
|
||||
}
|
||||
string getNum(int val) {
|
||||
string res;
|
||||
if(val >= 1000) {
|
||||
res += retNum(val / 1000);
|
||||
if(val % 1000 == 0) return res + num[1000];
|
||||
res += t[1000];
|
||||
val %= 1000;
|
||||
}
|
||||
if(val >= 100) {
|
||||
res += retNum(val / 100);
|
||||
if(val % 100 == 0) return res + num[100];
|
||||
res += t[100];
|
||||
val %= 100;
|
||||
}
|
||||
if(val >= 20) {
|
||||
if(val % 10 == 0) return res += num[val];
|
||||
res += retNum(val / 10 * 10);
|
||||
return res + num[val % 10];
|
||||
}
|
||||
else {
|
||||
return res + num[val];
|
||||
}
|
||||
}
|
||||
void init()
|
||||
{
|
||||
num[30] = "thirtieth";t[30] = "thirty";
|
||||
num[40] = "fortieth";t[40] = "forty";
|
||||
num[50] = "fiftieth";t[50] = "fifty";
|
||||
num[60] = "sixtieth";t[60] = "sixty";
|
||||
num[70] = "seventieth";t[70] = "seventy";
|
||||
num[80] = "eightieth";t[80] = "eighty";
|
||||
num[90] = "ninetieth";t[90] = "ninety";
|
||||
num[100] = "hundredth";t[100] = "hundred";
|
||||
num[1000] = "thousandth";t[1000] = "thousand";
|
||||
}
|
||||
int judge(string s)
|
||||
{
|
||||
int i,m=0,len=s.length();
|
||||
for(i=0;i<len;i++)
|
||||
if(s[i]=='t')
|
||||
m++;
|
||||
return m;
|
||||
}
|
||||
int numm[110000];
|
||||
void bfs()
|
||||
{
|
||||
int sum=5,m=11,cnt=3;
|
||||
numm[1]=1;
|
||||
numm[2]=4;
|
||||
numm[3]=11;
|
||||
queue <string> que;
|
||||
que.push(getNum(4));
|
||||
que.push(getNum(11));
|
||||
while(!que.empty())
|
||||
{
|
||||
int i,len;
|
||||
string str=que.front();
|
||||
que.pop();
|
||||
len=str.length();
|
||||
for(i=0;i<len;i++)
|
||||
{
|
||||
if(str[i]=='t')
|
||||
{
|
||||
numm[++cnt]=m+i+1;
|
||||
string tem=getNum(m+i+1);
|
||||
sum+=judge(tem);
|
||||
if(sum<=100100)
|
||||
{
|
||||
que.push(tem);
|
||||
}
|
||||
}
|
||||
}
|
||||
m+=str.length();
|
||||
}
|
||||
}
|
||||
int main (void)
|
||||
{
|
||||
int n;
|
||||
init();
|
||||
bfs();
|
||||
while (scanf("%d",&n),n)
|
||||
printf("%d\n",numm[n]);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(cin >> n && n)
|
||||
{
|
||||
int cnt = 0;
|
||||
while(n!=1)
|
||||
{
|
||||
if(n%2)
|
||||
n = (3*n+1)/2;
|
||||
else
|
||||
n = n/2;
|
||||
cnt++;
|
||||
}
|
||||
cout << cnt << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
char str[1000];
|
||||
int z,o,j;
|
||||
while(gets(str))
|
||||
{
|
||||
if(!strcmp(str,"E"))
|
||||
break;
|
||||
z = o = j = 0;
|
||||
int len = strlen(str);
|
||||
int i;
|
||||
for(i = 0;i<len;i++)
|
||||
{
|
||||
if(str[i] == 'Z')
|
||||
z++;
|
||||
else if(str[i] == 'O')
|
||||
o++;
|
||||
else if(str[i] == 'J')
|
||||
j++;
|
||||
}
|
||||
while(z || o || j)
|
||||
{
|
||||
if(z)
|
||||
{
|
||||
cout << "Z";
|
||||
z--;
|
||||
}
|
||||
if(o)
|
||||
{
|
||||
cout << "O";
|
||||
o--;
|
||||
}
|
||||
if(j)
|
||||
{
|
||||
cout << "J";
|
||||
j--;
|
||||
}
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int a[1005],i,flag[1005];
|
||||
while(cin >> n && n)
|
||||
{
|
||||
memset(flag,0,sizeof(flag));
|
||||
for(i = 0; i<n; i++)
|
||||
{
|
||||
cin >> a[i];
|
||||
flag[a[i]] = 1;
|
||||
}
|
||||
for(i = 0; i<n; i++)
|
||||
{
|
||||
int t;
|
||||
t = a[i];
|
||||
if(!flag[t])
|
||||
continue;
|
||||
while(t>1)
|
||||
{
|
||||
if(t%2)
|
||||
t = (t*3+1)/2;
|
||||
else
|
||||
t = t/2;
|
||||
if(t<=1000)
|
||||
{
|
||||
flag[t] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
int k = 1;
|
||||
for(i = n-1; i>=0; i--)
|
||||
{
|
||||
if(flag[a[i]])
|
||||
{
|
||||
if(k)
|
||||
{
|
||||
cout << a[i];
|
||||
k = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << " " << a[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
int a[100010];
|
||||
int aux[100010];
|
||||
void swap(int *a,int *b){
|
||||
int t=*a;
|
||||
*a=*b;
|
||||
*b=t;
|
||||
}
|
||||
int partition(int a[],int l,int h){
|
||||
int i=l;
|
||||
int j=h+1;
|
||||
int v=a[l];
|
||||
while(1){
|
||||
while(a[++i]>v)if(i==h)break;
|
||||
while(a[--j]<v)if(j==l)break;
|
||||
if(i>=j)break;
|
||||
swap(&a[i],&a[j]);
|
||||
}
|
||||
swap(&a[l],&a[j]);
|
||||
return j;
|
||||
}
|
||||
void q_sort(int a[], int l,int h){
|
||||
if(l>=h)return;
|
||||
int j=partition(a,l,h);
|
||||
q_sort(a,l,j-1);
|
||||
q_sort(a,j+1,h);
|
||||
}
|
||||
void merge(int a[],int l,int mid,int h){
|
||||
int i=l;
|
||||
int j=mid+1;
|
||||
for(int k=l;k<=h;++k)
|
||||
aux[k]=a[k];
|
||||
for(int k=l;k<=h;++k){
|
||||
if(i>mid)a[k]=aux[j++];
|
||||
else if(j>h)a[k]=aux[i++];
|
||||
else if(aux[i]>aux[j])a[k]=aux[i++];
|
||||
else a[k]=aux[j++];
|
||||
}
|
||||
}
|
||||
void m_sort(int a[],int l,int h){
|
||||
if(h<=l)return ;
|
||||
int mid=l+(h-l)/2;
|
||||
m_sort(a , l , mid);
|
||||
m_sort(a,mid+1,h);
|
||||
merge(a,l,mid,h);
|
||||
}
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int n,m;
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
if(n==0&&m==0)return 0;
|
||||
for(int i=0;i<n;++i)
|
||||
scanf("%d",&a[i]);
|
||||
q_sort(a,0,n-1);
|
||||
for(int i=0;;++i)
|
||||
{
|
||||
if(m)printf("%d",a[i]);
|
||||
m--;
|
||||
if(m)printf(" ");
|
||||
if(m==0)break;
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
int p[26];
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
while(cin>>n>>m)
|
||||
{
|
||||
if(n==0&&m==0) break;
|
||||
memset(p,-1,sizeof(p));
|
||||
char c;
|
||||
char p1;
|
||||
char p2;
|
||||
string s;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
cin>>s;
|
||||
c=s[0];
|
||||
p1=s[1];
|
||||
p2=s[2];
|
||||
if(p1!='-') p[p1-'A']=c-'A';
|
||||
if(p2!='-') p[p2-'A']=c-'A';
|
||||
}
|
||||
char c1,c2;
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
cin>>s;
|
||||
c1=s[0];
|
||||
c2=s[1];
|
||||
int count1=0,count2=0;
|
||||
int target1=c1-'A';
|
||||
int target2=c2-'A';
|
||||
int cur=target1;
|
||||
while(cur!=target2)
|
||||
{
|
||||
cur=p[cur];
|
||||
if(cur==-1)
|
||||
{
|
||||
count1=0;
|
||||
break;
|
||||
}
|
||||
else count1++;
|
||||
}
|
||||
if(count1==0)
|
||||
{
|
||||
cur=target2;
|
||||
while(cur!=target1)
|
||||
{
|
||||
cur=p[cur];
|
||||
if(cur==-1)
|
||||
{
|
||||
count2=0;
|
||||
break;
|
||||
}
|
||||
else count2++;
|
||||
}
|
||||
}
|
||||
if(count1==0&&count2==0)
|
||||
{
|
||||
cout<<'-'<<endl;
|
||||
}
|
||||
else if(count1!=0)
|
||||
{
|
||||
if(count1==1) cout<<"parent"<<endl;
|
||||
else if(count1==2) cout<<"grandparent"<<endl;
|
||||
else
|
||||
{
|
||||
while(count1>=3)
|
||||
{
|
||||
cout<<"great-";
|
||||
count1--;
|
||||
}
|
||||
cout<<"grandparent"<<endl;
|
||||
}
|
||||
}
|
||||
else if(count2!=0)
|
||||
{
|
||||
if(count2==1) cout<<"child"<<endl;
|
||||
else if(count2==2) cout<<"grandchild"<<endl;
|
||||
else
|
||||
{
|
||||
while(count2>=3)
|
||||
{
|
||||
cout<<"great-";
|
||||
count2--;
|
||||
}
|
||||
cout<<"grandchild"<<endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
__int64 a,b;
|
||||
char s1[20],s2[20];
|
||||
int len1,len2;
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
while(~scanf("%s%s",s1,s2))
|
||||
{
|
||||
len1 = strlen(s1);
|
||||
len2 = strlen(s2);
|
||||
a = b = 0;
|
||||
for(i = 0; i<len1;i++)
|
||||
{
|
||||
if(s1[i]>='0' && s1[i]<='9')
|
||||
{
|
||||
a = a*10+s1[i]-'0';
|
||||
}
|
||||
}
|
||||
if(s1[0] == '-')
|
||||
a = -a;
|
||||
for(i=0;i<len2;i++)
|
||||
{
|
||||
if(s2[i]>='0' && s2[i]<='9')
|
||||
b = b*10+s2[i]-'0';
|
||||
}
|
||||
if(s2[0] == '-')
|
||||
b = -b;
|
||||
printf("%I64d\n",a+b);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 999999999
|
||||
using namespace std;
|
||||
int main(){
|
||||
string s;
|
||||
while(cin>>s){
|
||||
int a=0,b=0,c=0,z=0,i=0;
|
||||
bool flag=true;
|
||||
for(;s[i] != 'z' && s[i] != '\0';++i){
|
||||
if(s[i] != 'o'){cout<<"Wrong Answer"<<endl;flag=false;break;}
|
||||
else ++a;
|
||||
}
|
||||
++i;
|
||||
for(;s[i] != 'j' && s[i] != '\0' && flag;++i){
|
||||
if(s[i] != 'o'){cout<<"Wrong Answer"<<endl;flag=false;break;}
|
||||
else ++b;
|
||||
}
|
||||
++i;
|
||||
for(;s[i] != '\0' && flag;++i){
|
||||
if(s[i] != 'o'){cout<<"Wrong Answer"<<endl;flag=false;break;}
|
||||
else ++c;
|
||||
}
|
||||
if((!b || (a == 0 && c !=0) || (a !=0 && c == 0)) && flag){cout<<"Wrong Answer"<<endl;flag=false;}
|
||||
if(flag){
|
||||
if(a ==0 && c == 0 || (c%a == 0 && c/a == b))cout<<"Accepted"<<endl;
|
||||
else cout<<"Wrong Answer"<<endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct nation
|
||||
{
|
||||
long double gold;
|
||||
long double all;
|
||||
long double area;
|
||||
int id;
|
||||
int rate1;
|
||||
int rate2;
|
||||
int rate3;
|
||||
int rate4;
|
||||
int bestrate;
|
||||
int sortway;
|
||||
};
|
||||
int cmpway;
|
||||
bool cmp(nation a,nation b)
|
||||
{
|
||||
if(cmpway==0) return a.id<b.id;
|
||||
else if(cmpway==1)return a.gold>b.gold;
|
||||
else if(cmpway==2) return a.all>b.all;
|
||||
else if(cmpway==3) return a.gold/a.area>b.gold/b.area;
|
||||
else if(cmpway==4) return a.all/a.area>b.all/b.area;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
bool flag=0;
|
||||
while(cin>>n>>m)
|
||||
{
|
||||
nation p[n];
|
||||
vector<nation> vn;
|
||||
double gold,all,area;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%lf%lf%lf",&gold,&all,&area);
|
||||
p[i].gold=gold;
|
||||
p[i].all=all;
|
||||
p[i].area=area;
|
||||
p[i].id=i;
|
||||
}
|
||||
int temp;
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d",&temp);
|
||||
vn.push_back(p[temp]);
|
||||
vn[i].id=i;
|
||||
}
|
||||
if(m>0)
|
||||
{
|
||||
cmpway=1;
|
||||
sort(vn.begin(),vn.end(),cmp);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
vn[i].rate1=i;
|
||||
}
|
||||
for(int i=1;i<m;i++)
|
||||
{
|
||||
if(vn[i].gold==vn[i-1].gold) vn[i].rate1=vn[i-1].rate1;
|
||||
}
|
||||
cmpway=2;
|
||||
sort(vn.begin(),vn.end(),cmp);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
vn[i].rate2=i;
|
||||
}
|
||||
for(int i=1;i<m;i++)
|
||||
{
|
||||
if(vn[i].all==vn[i-1].all) vn[i].rate2=vn[i-1].rate2;
|
||||
}
|
||||
cmpway=3;
|
||||
sort(vn.begin(),vn.end(),cmp);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
vn[i].rate3=i;
|
||||
}
|
||||
for(int i=1;i<m;i++)
|
||||
{
|
||||
if(vn[i].gold/vn[i].area==vn[i-1].gold/vn[i-1].area) vn[i].rate3=vn[i-1].rate3;
|
||||
}
|
||||
cmpway=4;
|
||||
sort(vn.begin(),vn.end(),cmp);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
vn[i].rate4=i;
|
||||
}
|
||||
for(int i=1;i<m;i++)
|
||||
{
|
||||
if(vn[i].all/vn[i].area==vn[i-1].all/vn[i-1].area) vn[i].rate4=vn[i-1].rate4;
|
||||
}
|
||||
cmpway=0;
|
||||
sort(vn.begin(),vn.end(),cmp);
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
vn[i].bestrate=vn[i].rate1;
|
||||
vn[i].sortway=1;
|
||||
if(vn[i].rate2<vn[i].bestrate)
|
||||
{
|
||||
vn[i].bestrate=vn[i].rate2;
|
||||
vn[i].sortway=2;
|
||||
}
|
||||
if(vn[i].rate3<vn[i].bestrate)
|
||||
{
|
||||
vn[i].bestrate=vn[i].rate3;
|
||||
vn[i].sortway=3;
|
||||
}
|
||||
if(vn[i].rate4<vn[i].bestrate)
|
||||
{
|
||||
vn[i].bestrate=vn[i].rate4;
|
||||
vn[i].sortway=4;
|
||||
}
|
||||
}
|
||||
for(int i=0;i<m;i++)
|
||||
printf("%d:%d\n",vn[i].bestrate+1,vn[i].sortway);
|
||||
}
|
||||
cout<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cstdlib>
|
||||
using namespace std;
|
||||
#define INF 0x7fffffff
|
||||
int n,m;
|
||||
int map[1005][1005];
|
||||
int cost[1005][1005];
|
||||
void dijkstra(int st,int ed)
|
||||
{
|
||||
int i,j,v,Min;
|
||||
int visit[1005],dis[1005],value[1005];
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
dis[i]=map[st][i];
|
||||
value[i]=cost[st][i];
|
||||
}
|
||||
memset(visit,0,sizeof(visit));
|
||||
visit[st]=1;
|
||||
for(i=1;i<n;i++)
|
||||
{
|
||||
Min=INF;
|
||||
for(j=1;j<=n;j++)
|
||||
if(!visit[j]&&dis[j]<Min)
|
||||
{
|
||||
v=j;
|
||||
Min=dis[j];
|
||||
}
|
||||
visit[v]=1;
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if(!visit[j]&&map[v][j]<INF)
|
||||
{
|
||||
if(dis[j]>dis[v]+map[v][j])
|
||||
{
|
||||
dis[j]=dis[v]+map[v][j];
|
||||
value[j]=value[v]+cost[v][j];
|
||||
}
|
||||
else if(dis[j]==dis[v]+map[v][j])
|
||||
{
|
||||
if(value[j]>value[v]+cost[v][j])
|
||||
value[j]=value[v]+cost[v][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d %d\n",dis[ed],value[ed]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,st,ed;
|
||||
int a,b,c,d;
|
||||
while(scanf("%d%d",&n,&m),n||m)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
map[i][j]=INF;
|
||||
cost[i][j]=INF;
|
||||
}
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d%d%d",&a,&b,&c,&d);
|
||||
if(map[a][b]>c)
|
||||
{
|
||||
map[a][b]=map[b][a]=c;
|
||||
cost[a][b]=cost[b][a]=d;
|
||||
}
|
||||
else if(map[a][b]==c)
|
||||
{
|
||||
if(cost[a][b]>d)
|
||||
cost[a][b]=cost[b][a]=d;
|
||||
}
|
||||
}
|
||||
scanf("%d%d",&st,&ed);
|
||||
dijkstra(st,ed);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
typedef struct Node
|
||||
{
|
||||
int data;
|
||||
struct Node *lc,*rc;
|
||||
}node,*Link;
|
||||
int n,f,c,cnt;
|
||||
char f1[11],la1[11],f2[11],la2[11];
|
||||
void insert( Link *L,int x )
|
||||
{
|
||||
if( *L )
|
||||
{
|
||||
if( x < ( *L ) -> data )
|
||||
insert( &( *L ) -> lc , x );
|
||||
else
|
||||
insert( &( *L ) -> rc , x );
|
||||
}
|
||||
else
|
||||
{
|
||||
*L = new node;
|
||||
( *L ) -> data = x;
|
||||
( *L ) -> lc = ( *L ) -> rc = NULL;
|
||||
}
|
||||
}
|
||||
void print1(Link L,char f[] )
|
||||
{
|
||||
if( L )
|
||||
{
|
||||
f[cnt++] = L ->data + '0';
|
||||
print1( L -> lc ,f);
|
||||
print1( L -> rc ,f);
|
||||
}
|
||||
}
|
||||
void print2( Link L, char la[] )
|
||||
{
|
||||
if( L )
|
||||
{
|
||||
print2( L -> lc, la );
|
||||
print2( L -> rc, la );
|
||||
la[cnt++] = L -> data + '0' ;
|
||||
}
|
||||
}
|
||||
int main( )
|
||||
{
|
||||
while( scanf( "%d",&n ),n )
|
||||
{
|
||||
f = 1;
|
||||
Link L = NULL;
|
||||
Link L1 = NULL;
|
||||
char str[11];
|
||||
scanf( "%s",str );
|
||||
c = strlen( str );
|
||||
for( int i = 0; i < c; ++i )
|
||||
insert( &L , str[i] - '0' );
|
||||
cnt = 0;
|
||||
print1( L ,f1);
|
||||
f1[cnt] = 0;
|
||||
cnt = 0;
|
||||
print2( L,la1 );
|
||||
la1[cnt] = 0;
|
||||
for( int i = 0; i < n; ++i )
|
||||
{
|
||||
f = 1;
|
||||
memset( f2,0,sizeof( f2 ) );
|
||||
memset( la2,0,sizeof( la2 ) );
|
||||
scanf( "%s",str );
|
||||
c = strlen( str );
|
||||
for( int i = 0; i < c; ++i )
|
||||
insert( &L1, str[i] - '0' );
|
||||
cnt = 0;
|
||||
print1( L1,f2 );
|
||||
f2[cnt] = 0;
|
||||
cnt = 0;
|
||||
print2( L1,la2 );
|
||||
la2[cnt] = 0;
|
||||
if( strcmp( f1,f2 ) != 0 || strcmp( la1,la2 ) != 0 )
|
||||
f = 0;
|
||||
free( L1 );
|
||||
L1 = NULL;
|
||||
puts( f ? "YES" : "NO" );
|
||||
}
|
||||
free( L );
|
||||
L = NULL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<string.h>
|
||||
int vis[100000+100];
|
||||
int prime[80000],c;
|
||||
int a[100000+10];
|
||||
void get_prime()
|
||||
{
|
||||
int i,j,n,m;
|
||||
c=0;
|
||||
n=100000;
|
||||
m=(int)sqrt(n+0.5);
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(i=2;i<=m;i++) if(!vis[i])
|
||||
{
|
||||
for(j=i*i;j<=n;j+=i) vis[j]=1;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,n,max;
|
||||
get_prime();
|
||||
n=0;
|
||||
a[1]=0;a[0]=0;a[2]=0;a[3]=0;a[4]=0;
|
||||
for(i=4;i<=100000;i++)
|
||||
{
|
||||
if(!vis[i]&&!vis[i-2])
|
||||
{
|
||||
n++;
|
||||
}
|
||||
a[i]=n;
|
||||
}
|
||||
while(i<=100000)
|
||||
{
|
||||
a[i++]=n;
|
||||
}
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
if(n<0) break;
|
||||
printf("%d\n",a[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include "iostream"
|
||||
#include "stdio.h"
|
||||
#include "math.h"
|
||||
#include "vector"
|
||||
#include "queue"
|
||||
#include "memory.h"
|
||||
#include "algorithm"
|
||||
#include "string.h"
|
||||
using namespace std;
|
||||
#define N 105
|
||||
char str[N];
|
||||
int Div(int s,int t)
|
||||
{
|
||||
int center=-2;
|
||||
if(s==t)
|
||||
center=-1;
|
||||
bool flag=(t-s+1)%2;
|
||||
while(t>s&&str[s]==str[t])
|
||||
s++,t--;
|
||||
if(s>t&&!flag)//even
|
||||
center=-1;
|
||||
else if(s==t&&flag)//odd
|
||||
center=s;
|
||||
return center;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int center1,center2,center;
|
||||
while(cin>>str&&strcmp(str,"#")!=0)
|
||||
{
|
||||
int len=strlen(str);
|
||||
bool flag=false;
|
||||
for(int i=0;i<len;i++)
|
||||
{
|
||||
center1=Div(0,i);
|
||||
center2=Div(i+1,len-1);
|
||||
if(center1!=-2&¢er2!=-2)
|
||||
{
|
||||
center=center1==-1?center2:center1;
|
||||
cout<<"YES "<<center<<endl;
|
||||
flag=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!flag)
|
||||
printf("NO\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include "iostream"
|
||||
#include "stdio.h"
|
||||
#include "math.h"
|
||||
#include "vector"
|
||||
#include "queue"
|
||||
#include "memory.h"
|
||||
#include "algorithm"
|
||||
#include "string.h"
|
||||
using namespace std;
|
||||
#define N 1000005
|
||||
__int64 a1[N];
|
||||
__int64 a2[N];
|
||||
int main()
|
||||
{
|
||||
int n1,n2,i,j;
|
||||
while(scanf("%d",&n1)!=EOF&&n1>=0)
|
||||
{
|
||||
for(i=0;i<n1;i++)
|
||||
scanf("%I64d",&a1[i]);
|
||||
scanf("%d",&n2);
|
||||
for(i=0;i<n2;i++)
|
||||
scanf("%I64d",&a2[i]);
|
||||
sort(a1,a1+n1);
|
||||
sort(a2,a2+n2);
|
||||
i=0;
|
||||
__int64 sum=0;
|
||||
while(a1[i]<0&&a2[i]<0&&i<n1&&i<n2)
|
||||
sum+=a1[i]*a2[i++];
|
||||
i=n1-1,j=n2-1;
|
||||
while(a1[i]>0&&a2[j]>0&&i>=0&&j>=0)
|
||||
sum+=a1[i--]*a2[j--];
|
||||
printf("%I64d\n",sum);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue