A-ZJH and Monkey
/******************************************************
Author Ms.Wen
Date 2018/5/3
解题思路：题目的意思是，对于题目中给出的图，有多少(a,b,c)使得 abs(abs(ca)-abs(cb))的奇偶性和题目给出的n相同。
则我们需要知道图中有多少对点的距离是奇数，多少对点的距离。更简单算法是可以转化为求1到各个点距离的奇偶性，这
一点让人有点楞，因为当时在想，图又不是一条线这样能行吗。后来在纸上写了还真是这样的。假如a,b的最近共同祖先是
c。则有下面六种情况。
(1)1到c的距离为奇数,c到a的距离为偶数，则1到a的距离为奇数，c到b的距离为偶数，则1到b的距离为奇数，则和ab的距离为偶数对应。
(2)1到c的距离为奇数,c到a的距离为偶数，则1到a的距离为奇数，c到b的距离为奇数，则1到b的距离为偶数，则和ab的距离为奇数对应。
(3)1到c的距离为奇数,c到a的距离为奇数，则1到a的距离为偶数，c到b的距离为奇数，则1到b的距离为偶数，则和ab的距离为偶数对应。
(4)1到c的距离为偶数,c到a的距离为偶数，则1到a的距离为偶数，c到b的距离为偶数，则1到b的距离为偶数，则和ab的距离为偶数对应。
(5)1到c的距离为偶数,c到a的距离为偶数，则1到a的距离为偶数，c到b的距离为奇数，则1到b的距离为奇数，则和ab的距离为奇数对应。
(6)1到c的距离为偶数,c到a的距离为奇数，则1到a的记录为奇数，c到b的距离为奇数，则1到b的距离为奇数，则和ab的距离为偶数对应。
则可以知道我们真的可以把两点距离的奇偶性通过点1到其他点距离的奇偶性组合得到。
n是偶数可以有下面的情况：
(1)偶偶偶 偶-偶 = 偶 偶-偶 = 偶
(2)偶偶奇 奇-偶 = 奇 奇-奇 = 偶
(3)奇奇奇 奇-奇 = 偶 偶-偶 = 偶
(4)奇奇偶 偶-奇 = 奇 奇-奇 = 偶
n是奇数可以有下面的情况：
(1)偶奇偶 偶-偶 = 偶 偶-奇 = 奇 偶-奇 = 奇
(2)奇偶偶 偶-奇 = 奇 偶-偶 = 偶 奇-偶 = 奇
(3)奇偶奇 奇-奇 = 偶 奇-偶 = 奇 偶-奇 = 奇
(4)偶奇奇 奇-偶 = 奇 奇-奇 = 偶 奇-偶 = 奇
变量含义：
vis:标记数组，保证dfs过程中访问过的点不再访问
v:用来存放图的容器
odd:统计奇数距离
even:统计偶数距离
**************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int maxn = 1e5+10;
typedef long long ll;
ll odd,even;
int vis[maxn];
vector<int>v[maxn];
void dfs(int x,int depth) {
if(depth%2==0) even++;
else odd++;
for(int i = 0; i < (int)v[x].size(); i++) {
int y = v[x][i];
if(vis[y]==0) {
vis[y] = 1;
dfs(y,depth+1);
}
}
}
int main() {
int t,n,a,b;
scanf("%d",&t);
while(t--) {
scanf("%d",&n);
for(int i = 0; i <= n; i++) {
v[i].clear();
}
for(int i = 1; i < n; i++) {
scanf("%d%d",&a,&b);
v[a].push_back(b);
v[b].push_back(a);
}
odd = 0;
even = 0;
memset(vis,0,sizeof(vis));
vis[1] = 1;
dfs(1,0); //求1到其他点的距离。
ll ans;
//是奇数
if(n%2) {
//四种：偶奇偶、奇偶偶、奇偶奇、偶奇奇
ans = even*odd*even + odd*even*even + odd*even*odd + even*odd*odd;
}
else {
//四种：偶偶偶、偶偶奇、奇奇奇、奇奇偶
ans = even*even*even + even*even*odd + odd*odd*odd + odd*odd*even;
}
printf("%lld\n",ans);
}
return 0;
}B-Beautiful Trees Cutting
/*********************************************
Author Ms. Wen
Date 2018/5/2
解题思路：
如果计算的数字能被5乘除，则字符串要以'0'或'5'结尾，假如第i个字符是
'0'或者'5'。则以第i个字符为结尾，其前方0~i-1个字符，均考虑删与不删。
则有2^i。由于字符串要出现k此，则在第二个串的i位置的字符对应2^(i+len-1).
第三个串的i位置的字符对应2^(i+2*len-1).则对应第i个位置这个字符。其满足
ai = 2^i 公比为 q = 2^len的等比数列。则对应第i个位置这个字符的方案数
为 ai*(q^k-1)/(q-1). 当然一个串中像i这样的位置由多个。则可以求出
sum = Sum(ai) [ai = 2^i && 字符i是'0'或'5'。
然后用整数快速幂求q^k-1。由于取模的数是素数，则用费马小定理求q-1的乘法
逆元。
*************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
typedef long long ll;
const int mod = 1e9+7;
const int maxn = 1e5+10;
char str[maxn];
ll quickPow(ll n,ll k) {
ll ans,res;
ans = 1;
res = n;
while(k) {
if(k&1) {
ans = ans*res%mod;
}
res = res*res%mod;
k = k/2;
}
return ans;
}
int main() {
int k;
while(~scanf("%d %s",&k,str)) {
int len = strlen(str);
ll sum = 0;
for(int i = 0; i < len; i++) {
if(str[i]=='0' || str[i]=='5'){
sum += quickPow((ll)2,i);
sum %= mod;
}
}
ll q = quickPow((ll)2,len);
sum = sum*(((quickPow(q,(ll)k)-1)+mod)%mod);
sum = sum%mod;
q = (q-1+mod)%mod;
q = quickPow(q,mod-2);
sum = sum*q%mod;
cout<<sum<<endl;
}
return 0;
}C-Professional Manager
/*****************
Author Ms. Wen
Date 2018/5/2
解题思路：
除了第2个操作，其他三个都是普通并查集。当我在冥思苦想怎么把一个点
剥离出来的，感觉不好办，看了一眼题解，方法真的挺巧妙，剥离一个点后，
我们直接创建一个新的点，让它代表原来的点就行了。第一次这样写，又学
到一招。
变量含义：
f:f[i]存放i的前驱
id:id[i]存放点i的编号，因为点的编号在算法执行过程中会变。
num:num[i]代表i这个集合，有多少颗树。
cnt:用来增加新节点。
************************/
#include <iostream>
#include <stdio.h>
using namespace std;
const int maxn = 1e6;
int f[maxn],id[maxn],num[maxn],cnt;
//初始化
void initSet(int n) {
for(int i = 1; i <= n; i++) {
f[i] = id[i] = i;
num[i] = 1;
}
}
//寻找树根
int findSet(int x) {
int tmp = id[x];
while(tmp != f[tmp]) {
tmp = f[tmp];
}
return tmp;
}
//合并集合
void unionSet(int u,int v) {
int fu = findSet(u);
int fv = findSet(v);
if(fu != fv) {
f[fu] = fv;
num[fv] += num[fu];
}
}
//分离点u
void separate(int u) {
int fu = findSet(u);
num[fu]--;
id[u] = (++cnt);
}
int main() {
int t,n,q,op,u,v;
scanf("%d",&t);
for(int i = 1; i <= t; i++) {
printf("Case #%d:\n",i);
scanf("%d%d",&n,&q);
initSet(n+q);
cnt = n;
while(q--) {
scanf("%d",&op);
if(op == 1) {
scanf("%d%d",&u,&v);
unionSet(u,v);
}
else if(op == 2) {
scanf("%d",&u);
separate(u);
}
else if(op == 3) {
scanf("%d",&u);
int fu = findSet(u);
printf("%d\n",num[fu]);
}
else {
scanf("%d%d",&u,&v);
int fu = findSet(u);
int fv = findSet(v);
if(fu == fv) {
printf("YES\n");
}
else {
printf("NO\n");
}
}
}
}
return 0;
}D-
E-
F-Sorting Trees
/*****************************
Author Ms. Wen
Date 2018/4/29
解题思路：
(1)k = 0时，不会发生任何交换，答案就是排序后的序列和原序列
第一个不同的位置，如果不存在不相同的位置，答案为-1.
(2)k = 1时，就是冒泡排序，则将来序列值和排序后的相同，直接
输出-1.
(3)其他情况，我们知道i,i+k,i+2k,i+3k....i+mk。它们可以交换，
即最终他们是通过交换，从小到达排列的。遇到一个i，将i,i+k,i+2k,
i+3k....i+mk抽出，进行排序，排序后，再将他们放回原位。然后比较
sort后的原始序列和经过错误排序方法排序后的序列。即可得出答案。
变量含义：
arr:存放原始序列。
sorted:存放arr进行sort排序后的序列。
vis:用来标记某个位置上的数是否已经被处理过。
tmp:用来临时存放抽出的i,i+k,i+2k,....i+mk.
wrongSorted:用来存放错误排序算法，排序后的序列。
**************************************************/
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn = 1e5+10;
int arr[maxn],sorted[maxn],vis[maxn];
int tmp[maxn],wrongSorted[maxn];
int main() {
int n,k;
while(~scanf("%d%d",&n,&k)) {
for(int i = 1; i <= n; i++) {
scanf("%d",&arr[i]);
sorted[i] = arr[i];
}
//k=0，序列不会进行任何交换。
if(k == 0) {
sort(sorted+1,sorted+n+1);
bool flag = true;
for(int i = 1; i <= n; i++) {
if(sorted[i] != arr[i]) {
printf("%d\n",i);
flag = false;
break;
}
}
if(flag) {
printf("-1\n");
}
}
else if(k == 1) { //等价于冒泡排序。
printf("-1\n");
}
else {
sort(sorted+1,sorted+1+n);
int cnt,sum = 0;
memset(vis,0,sizeof(vis));
for(int i = 1; i <= n; i++) {
if(vis[i]) continue;
cnt = 0;
for(int j = i; j <= n; j+=k) {
tmp[cnt++] = arr[j];
vis[j] = 1;
}
sort(tmp,tmp+cnt);
int y = i;
for(int j = 0; j < cnt; j++) {
wrongSorted[y] = tmp[j];
y += k;
}
sum += cnt;
if(sum == n) break; //sum = n代表所有数字都过了一遍。
}
bool flag = true;
for(int i = 1; i <= n; i++) {
if(sorted[i] != wrongSorted[i]) {
printf("%d\n",i);
flag = false;
break;
}
}
if(flag) {
printf("-1\n");
}
}
}
return 0;
}G-Triangular garden
/***********************************
Author Ms. Wen
Date 2018/5/3
解题思路：
题目给出三角形三点坐标，再给出一点坐标。如果这一点是三角形的
4心之一，则输出Yes,否则输出No。四心分别是：
(1)垂心：三条边高线的交点
(2)重心：三条边的中线的交点
(3)内心: 三个角角平分线的交点。因为角平分线上的点到两边线段的距离相等。
(4)外心：三个边垂直平分线的交点。因为线段垂直平分线上的点到线段两端点的距离相等。
重心和外心最好判断，其次是垂心，内心最复杂。
(1)重心，一直三角形三点(x1,y1),(x2,y2),(x3,y3). 其重心坐标(（x1+x2+x3)/3,(y1+y2+y3)/3 )。
(2)外心，是三角形外接圆圆心，则三角形三个点在外接圆上，判断三点到圆心的距离相等。
(3)垂心，因为是高的交线，则可以证明vector(AB)*vector(AO) = 0。vector代表向量。
(4)外心，则判断vector(AB)和vector(AO) 和 vector(AC)和vector(AO) 向量间夹角相同。
**************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#define eps 1e-8
using namespace std;
typedef long long ll;
ll px1,px2,px3,py1,py2,py3;
ll x,y;
//判断垂心。
bool check1() {
ll a,b,u,v;
a = px1-px2;
b = py1-py2;
u = px3-x;
v = py3-y;
if(a*u+b*v != 0) {
return false;
}
a = px1-px3;
b = py1-py3;
u = px2-x;
v = py2-y;
if(a*u+b*v != 0) {
return false;
}
a = px2-px3;
b = py2-py3;
u = px1-x;
v = py1-y;
if(a*u+b*v != 0) {
return false;
}
return true;
}
//判断重心
bool check2() {
if(px1+px2+px3==3*x && py1+py2+py3==3*y) return true;
return false;
}
//判断向量间的夹角是否相等。
bool equals(ll xx1,ll yy1,ll xx,ll yy,ll xx2,ll yy2) {
double cosA = (xx1*xx+yy1*yy)/(sqrt(xx1*xx1+yy1*yy1)*sqrt(xx*xx+yy*yy));
double cosB = (xx2*xx+yy2*yy)/(sqrt(xx2*xx2+yy2*yy2)*sqrt(xx*xx+yy*yy));
if(fabs(cosA-cosB)<eps) {
return true;
}
return false;
}
//判断内心
bool check3() {
bool flag;
flag = equals(px2-px1,py2-py1,x-px1,y-py1,px3-px1,py3-py1);
if(!flag) return false;
flag = equals(px1-px3,py1-py3,x-px3,y-py3,px2-px3,py2-py3);
if(!flag) return false;
flag = equals(px1-px2,py1-py2,x-px2,y-py2,px3-px2,py3-py2);
return flag;
}
//判断外心
bool check4() {
ll dist1 = (px1-x)*(px1-x) + (py1-y)*(py1-y);
ll dist2 = (px2-x)*(px2-x) + (py2-y)*(py2-y);
ll dist3 = (px3-x)*(px3-x) + (py3-y)*(py3-y);
if(dist1==dist2 && dist2==dist3 && dist1==dist3) {
return true;
}
return false;
}
int main() {
while(~scanf("%lld%lld%lld%lld%lld%lld%lld%lld",&px1,&py1,&px2,&py2,&px3,&py3,&x,&y)) {
if(check1() || check2() || check3() || check4()) {
printf("Yes\n");
}
else {
printf("No\n");
}
}
return 0;
}
H-
I-Neat Tree
/*****************************
Author Ms. Wen
Date 2018/5/4
解题思路：
使用单调栈，就是使用普通的栈去模拟，但是在操作过程中保持栈中元素
单调增或单调减。求解arr[i]作为最大值所能延伸到的左侧，右侧，以及
arr[i]作为最小值所能延伸到的左侧右侧。用栈模拟可以在线性时间复杂
度成功求解。
*******************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
using namespace std;
const int maxn = 1e6+10;
typedef long long ll;
int arr[maxn];
int L[maxn];
int R[maxn];
int main() {
int n;
while(~scanf("%d",&n)) {
for(int i = 1; i <= n; i++) {
scanf("%d",&arr[i]);
R[i] = n+1; //假设arr[i]右侧大于arr[i]的第一个数是其右侧的数。
}
ll ans = 0;
stack<int>st;
//保证栈里面是单调递减的。
for(int i = 1; i <= n; i++) {
//只要栈不空，且栈顶元素小于当前元素，当前元素就是栈顶元素右侧第一个大于其自身的元素。
while(!st.empty() && arr[st.top()]<arr[i]) {
R[st.top()] = i;
st.pop();
}
if(st.empty()) L[i] = 0;
else L[i] = st.top();
st.push(i);
}
//计算贡献。
for(int i = 1; i <= n; i++) {
ans = ans + (ll)(i-L[i])*(ll)(R[i]-i)*(ll)arr[i];
}
while(!st.empty()) st.pop();
for(int i = 1; i <= n; i++) {
R[i] = n+1;
}
//接下来保持队列中元素单调增。
for(int i = 1; i <= n; i++) {
while(!st.empty() && arr[st.top()]>arr[i]) {
R[st.top()] = i;
st.pop();
}
if(st.empty()) {
L[i] = 0;
}
else {
L[i] = st.top();
}
st.push(i);
}
for(int i = 1; i <= n; i++) {
ans = ans - (ll)(i-L[i])*(ll)(R[i]-i)*(ll)arr[i];
}
cout<<ans<<endl;
}
return 0;
}J-Various Tree(签到题)
/***********************
Author Ms. Wen
Date 2018/4/29
解题思路：
简单广搜，注意搜索的数字进行标记，否则同一数字
多次进队，内存可能会爆。
**************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
const int maxn = 1e6+10;
int fun[maxn];
int vis[maxn];
void init() {
memset(fun,0,sizeof(fun));
for(int i = 0; i <= 1e6; i++) {
int tmp = i;
while(tmp) {
if(tmp&1) {
fun[i]++;
}
tmp = tmp/2;
}
}
}
struct Node {
int x;
int step;
};
int bfs(int a,int b) {
queue<Node>qu;
Node cur,nex;
memset(vis,0,sizeof(vis));
vis[a] = 1;
cur.x = a;
cur.step = 0;
qu.push(cur);
while(!qu.empty()) {
cur = qu.front();
qu.pop();
if(cur.x == b) {
return cur.step;
}
nex.step = cur.step + 1;
nex.x = cur.x + 1;
if(vis[nex.x]==0) {
vis[nex.x] = 1;
qu.push(nex);
}
nex.x = cur.x - 1;
if(vis[nex.x]==0){
vis[nex.x] = 1;
qu.push(nex);
}
nex.x = cur.x + fun[cur.x];
if(vis[nex.x]==0) {
vis[nex.x] = 1;
qu.push(nex);
}
nex.x = cur.x - fun[cur.x];
if(vis[nex.x]==0) {
vis[nex.x] = 1;
qu.push(nex);
}
}
return -1;
}
int main() {
init();
int a,b;
while(~scanf("%d%d",&a,&b)) {
printf("%d\n",bfs(a,b));
}
return 0;
}K-Walking in the Forest
/***********************
Author Ms. Wen
Date 2018/4/29
解题思路：
这个题目是这场比赛写的第一个题目，很快想到用二分来猜答案。
但是我没有处理好二分边界的问题，提交一直不对，但是感觉自己二分
写的挺对的。最后我自己算是水过的，因为我求出了ans,所以我最后认为
答案肯定离ans特别近，所以最后我先检测ans-1是否合法，合法就把ans-1输出，
否则在检测ans,合法把ans输出，然后再检测ans+1。如果和法把ans+1输出。
最后可算过了。找不出代码的错误，这个题目卡了好久。
**************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn = 1e5+10;
long long arr[maxn];
int n,k;
bool check(long long mid) {
long long sum = 0;
int step = 1;
for(int i = 1; i < n; i++) {
if(arr[i]>mid) return false; //如果一步直接超过mid,mid不行
sum += arr[i];
if(sum > mid) { //加上第i个超过mid,则另起一步。
step++;
sum = arr[i];
}
}
//如果步数不满足要求，mid也不行。
if(step > k) return false;
return true;
}
int main() {
while(~scanf("%d%d",&n,&k)) {
long long Max = 0;
for(int i = 1; i < n; i++) {
scanf("%lld",&arr[i]);
if(Max < arr[i]) {
Max = arr[i];
}
}
long long low,high,mid,ans;
low = 1;
high = Max*(n-1); //设个大一点的数。
while(low<=high) {
mid = (low+high)/2;
if(check(mid)) {
ans = mid;
high = mid-1;
}
else {
low = mid+1;
}
}
long long tmp = ans-1;
if(check(tmp)) {
cout<<tmp<<endl;
}
else if(check(ans)) {
cout<<ans<<endl;
}
else if(check(ans+1)) {
cout<<ans+1<<endl;
}
}
return 0;
}
L-
2193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
