2016年08月_围巾的ACM

原创 Codeforces Round #272 (Div. 2) D Dreamoon and Sets（构造）

思路：需要手玩一会.... #include using namespace std; int main() { int n,k; scanf("%d%d",&n,&k); printf("%d\n",(n-1)*k*6+5*k); for(int i=0;i<n;i++) printf("%d %d %d %d\n",i*k*6+k,i

2016-08-27 13:50:09 496

原创 Codeforces Round #272 (Div. 2) C Dreamoon and Sums（数学）

思路：将式子分母移过去其实就是x = m(kb+1)，m是x%b的值，显然m的取值范围是1到b-1，然后先求出m，然后枚举k即可 #include using namespace std; #define LL long long LL ans = 0; const LL mod = 1e9+7; int main() { LL a,b; scanf("%lld%lld",&

2016-08-27 13:49:10 1002

原创 Codeforces Round #272 (Div. 2) B Dreamoon and WiFi（简单DP）

思路：dp[i][j]表示考虑到执行第二个串的第i位现在在j位置的概率是多少。 #include using namespace std; double dp[100][100]; char s1[50],s2[50]; int main() { scanf("%s%s",s1+1,s2+1); int level = 50; int pos=50; i

2016-08-27 13:46:53 716

原创 Codeforces Round #272 (Div. 2) A Dreamoon and Stairs（水）

思路：水 #include using namespace std; int main() { int n,m,ans=1e9; scanf("%d%d",&n,&m); for(int i = 1;i<=n;i++) { if(i%m==0 && 2*i>=n) ans = min(ans,i); } if(ans==1e9) printf

2016-08-27 13:45:32 524

原创 HDU 5443 The Water Problem（水）

思路：没有修改，只有询问操作，可以RMQ，线段树等各种方法，当然也可以暴力 #include using namespace std; const int maxn = 1005; int a[maxn]; int main() { int T; scanf("%d",&T); while(T--) { int n; scanf("%d",&n);

2016-08-26 21:19:47 568

原创 HDU 5441 Travel（并查集）

思路：显然的mq这样的做法就T成狗...那么可以给边排个序，询问也排个序，然后扫过去，每次两个连通块合并的时候的答案就是(cnt[u]+cnt[v])*(cnt[u]+cnt[v]-1) - (cnt[u]*(cnt[u]-1))-(cnt[v]*(cnt[v]-1))嘛，然后就做完了 #include using namespace std; const int maxn = 2000

2016-08-26 21:18:30 686

原创 HDU 5437 Alisha’s Party（优先队列模拟）

思路：题目比较好懂的模拟题，用一个优先队列即可模拟的时候要注意最后还会再开一次门，把剩下的人全部放进来，开门的时间并不一定是递增的，要自己排个序，还有就是要注意开门的时候是2 5这种数据，就是到第二个人到了开门，然后可以放5个人进来，这样不处理的话会RE #include using namespace std; const int maxn = 150000+7

2016-08-26 21:15:56 636

原创 HDU 5438 Ponds（并查集）

思路：不断删除度数为1的点可以类似拓扑排序那样删除，然后并查集合并的时候统计一下顶点数和权值和就可以了 #include using namespace std; #define LL long long const int maxn = 10000+7; vectore[maxn]; int w[maxn],degree[maxn],fa[maxn],vis[maxn],cnt[max

2016-08-26 21:12:49 744

原创 Codeforces Round #368 (Div. 2) E Garlands（二维树状数组+暴力）

题意：给你n*m的矩阵，有k条链，两种操作，你可以每次修改一条链的值，使之变为0或者恢复原来的值，或者查询一个子矩阵的权值和思路：n,m,k只有2000，并且留意到题目说查询权值和的操作最多只有2000次，那么就可以不用每次修改的时候就马上修改，而是选择给它一个标记，到了询问的时候再遍历一次所有链来修改，有点类似线段树的lazy标志一样，查询子矩阵的权值和显然的做法就是用一个二维树状数组，这样

2016-08-24 12:54:07 716

原创 Codeforces Round #368 (Div. 2) D Persistent Bookcase（离线+DFS）

思路：离线把所有操作都存起来，并且对于前三个操作连i-1到i的边，第四个操作回到第K个结点那么连k到i的边，然后DFS记录变化就可以了，这个过程对于第一次接触可能不太好理解，可以结合代码看注意：加书本的时候如果本来就有的话这个操作相当于无效，同理对于去掉一本书，DFS的时候回溯的时候记得把原来标记的状态变回原来的 #include using namespace std; const

2016-08-23 20:49:13 379

原创 Codeforces Round #368 (Div. 2) C Pythagorean Triples（构造勾股数）

思路：只需要百度一下勾股数...就有构造方法了...不多说 #include using namespace std; #define LL long long int main() { LL n; scanf("%lld",&n); if(n==1 || n==2) { puts("-1"); return 0; } if(n&1) { n

2016-08-23 20:45:13 419

原创 Codeforces Round #368 (Div. 2) B Bakery（水）

思路：显然是直接连着仓库的点是最优解，枚举即可 #include using namespace std; #define LL long long const int maxn = 1e5+7; int a[maxn]; int vis[maxn]; vector >e[maxn]; int main() { int n,m,k; LL ans = 1e18; scanf("%d

2016-08-23 20:43:59 641

原创 Codeforces Round #368 (Div. 2) A Brain's Photos（水）

思路：水题 #include using namespace std; int main() { int n,m,flag=0; scanf("%d%d",&n,&m); for(int i = 1;i<=n;i++) for(int j = 1;j<=m;j++) { string s; cin >> s; if(s=="C" || s=="M" ||

2016-08-23 20:42:20 416

原创 HDU 3594 Cactus（强连通）

思路：判断一个图是否为强连通并且每条边仅属于一个环，我们把边的判断转化为对点的记录，在tarjan的过程里用一个fa数组记录每个结点的父子关系，当我们发现一条回边的时候从这个点向fa回溯，给点++，如果大于一证明这个点同时属于两个环 #include using namespace std; const int maxn = 20000+50; int in0[maxn],out0[ma

2016-08-17 15:21:08 452

原创 HDU 3861 The King’s Problem（tarjan+二分图匹配）

思路：首先同属一个州就证明两个城市是强连通的，又要使得对于每一个州里的任何两个城市u、v，都有不经过其他州的路从u到v或从v到u，其实就是一个二分图 #include using namespace std; const int maxn = 5000+50; int in0[maxn],out0[maxn]; vectore[maxn]; int pre[maxn],lowlink[m

2016-08-16 23:59:10 408

原创 HDU 1588 Gauss Fibonacci（矩阵快速幂）

思路：显然的有f(n)=A^n，那么把g(i)代入后有sum = A^b+A^(k+b)+A^(2k+b)+...A^((n-1)k+b) 提取A^b之后sum = A^b*(A^k^0+A^k^1+A^k^2+.....A^k^(n-1))，将A^k设为B的话那么就是一个简单的二分求和过程，注意最后要加上B^0 坑点：虽然最后结果不会爆long long，可是中途乘法过

2016-08-16 15:04:49 384

原创 HDU 1575 Tr A（矩阵快速幂）

思路：简单的矩阵快速幂 #include #include #include using namespace std; int n,mod; struct Mat { int a[31][31]; //矩阵大小 }; Mat mul(Mat a,Mat b) { Mat t; memset(t.a,0,sizeof(t.a)); for(int i = 0;i<n;i++)

2016-08-15 17:25:22 297

原创 POJ 3233 Matrix Power Series（矩阵快速幂）

思路：看k的范围显然不能直接遍历来加，留意到S有一个性质当k为偶数的时候 Sk = A+A^2+....A^(K/2)+A^(K/2)*(A+A^2+....A^(k/2)) 当k为奇数的时候 Sk = A+A^2+....A^(K/2)+A^((K+1)/2) + A^((K+1)/2)*(A+A^2....A^(K/2))

2016-08-15 17:12:32 315

原创 poj3070 Fibonacci（矩阵快速幂）

思路：矩阵快速幂的入门题 #include #include #include using namespace std; struct Mat { int a[2][2]; //矩阵大小 }; int n; const int mod = 10000; Mat mul(Mat a,Mat b) { Mat t; memset(t.a,0,sizeof(t.a)); for(i

2016-08-15 16:07:25 473

原创 HDU 2852 KiKi's K-Number（树状数组）

思路：三种操作，增加一个数，减少一个数，询问大于某个数的第k个数第一种操作就是普通的update，第二个询问前先求query(x)-query(x-1)是否为0，为0就是没有这个元素，第三个操作大于某个数的第K个数相当于求第query(x)+k个数，那么二分一下就可以了 #include using namespace std; const int maxn =

2016-08-14 10:31:25 354

原创 POJ 3321 Ultra-QuickSort（树状数组+DFS序）

思路：有两种操作，如果结点X有苹果那么拿掉，否则加一个苹果，操作二询问以某个结点为根的子树有多少个苹果，显然一开始给出的树的结点编号是无序的不利于维护，那么可以考虑DFS将结点都重新编号，那么一个子树的结点编号一定是连续的，然后用树状数组维护即可坑点：会卡STL #include #include #include #include using namespace std; cons

2016-08-13 23:35:51 367

原创 Codeforces Round #367 (Div. 2) D Vasiliy's Multiset（字典树）

思路：三个操作，增加删除和查找异或最大的，和去年长春区域赛的一道字典树基本一样... #include using namespace std; const int maxn = 3*1e6+7; struct Tree { int Next[maxn][2]; int val[maxn]; int L,root; void init() { L=0; root = n

2016-08-12 15:52:47 547

原创 Codeforces Round #367 (Div. 2) C Hard problem（DP）

思路：由于字符串之间的顺序是固定的，也就是转移的顺序也固定了，令dp[i][0]为第i个字符串不反转的最小费用，dp[i][1]为反转的最小费用，直接转移就可以了 #include using namespace std; const int maxn = 100000+5; #define LL long long #define inf 1e18 LL dp[maxn][2]; in

2016-08-12 15:50:35 372

原创 Codeforces Round #367 (Div. 2) B Interesting drink（二分）

思路：二分upper_bound就好了... #include using namespace std; const int maxn = 100000+5; int a[maxn]; int main() { int n; scanf("%d",&n); for(int i = 0;i<n;i++) scanf("%d",&a[i]); sort(a,a

2016-08-12 15:48:43 439

原创 Codeforces Round #367 (Div. 2)A

Codeforces Round #367 (Div. 2) A 思路：水题，直接算就可以了 #include using namespace std; int main() { double a,b; scanf("%lf%lf",&a,&b); int n; scanf("%d",&n); double ans = 1e9; for(int i = 1;i<=n;i+

2016-08-12 15:47:40 384

原创 hdu5823 color II（状态压缩DP）

题意：给你一个图G，求每个子图的最少染色数思路：每个子图的染色问题，可以看成是找每个子图的独立集问题（两两顶点互不相邻的图叫独立集），可以先枚举每个状态，然后枚举每个顶点，表示以这个顶点为起始的子图，再枚举每个顶点，表示这个顶点和上面那个顶点所构成的图是一个独立集，预处理出所有非法的状态，即他们之间有边。令dp[s]为子图S已经染色的最少染色数，那么有dp[s]=mi

2016-08-11 23:39:05 1057 1

原创 hdu5826 physics（物理推公式）

思路：这个题我的推导过程是vt^2-vo^2=2as, s=vt,c=av然后代一下就出来了...并没有积分..不过效果是一样的 #include #include #include using namespace std; const int N = 100005; struct node { double v, x, d; }que[N]; bool cmp(node a,

2016-08-11 21:33:35 541

原创 hdu5831 Rikka with Parenthesis II（水）

思路：最优情况下一定交换第一个右括号和最后一个左括号，交换后判断一下即可。时间复杂度O(n) 注意：我的代码那里n==2的时候都判了no其实是错的，还有n==2并且括号是)(的时候是yes的，数据出水了 #include using namespace std; char s[100005]; int main() { int T; scanf("%d",&T); wh

2016-08-11 21:31:25 610

原创 hdu5828 Rikka with Sequence（线段树）

思路：HDU4027的升级版，多了一个区间add的操作，考虑一下显然开根号的递减速度是很快的，2^64最多不超过8次就能减到1，而且会出现很多区间的数字都是一样的情况，那么可以在线段树多维护一个flag值，表示区间里面是否所有数都是相等的，如果是的话那么开根号就只开到这里就行了，具体实现细节还是蛮多的.... #include using namespace std; const int

2016-08-11 21:28:10 826

原创 HDU 3001 Travelling（状态压缩DP）

思路：类似TSP问题，不过每个点可以经过不超过两次，那么就可以考虑用三进制来压缩状态，先预处理出每个数的三进制的第j位是什么，然后其他就和TSP类似的坑点：有重边 #include using namespace std; const int maxn = 60000; #define inf 0x3f3f3f int three[]={0,1,3,9,27,81,243,729,2187,

2016-08-11 10:45:45 388

原创 POJ 3311 Hie with the Pie（状压DP）

思路：一个类似TSP的问题，只是每个点可以走多次，floyd预处理一下两两之间的距离。求最短距离。城市只有10个，所以可以考虑状态压缩，令dp[s][i]为到了i点时状态为s的最短距离，那么dp[s][i]=min(dp[s][i],dp[ss][j]+d[j][i]) #include #include #include using namespace std; #define

2016-08-11 01:55:26 415

原创 HDU 1043 Eight（BFS）

思路：八数码问题首先要会康托展开来表示它的状态，根据逆序数直接判断有无解，对于一个八数码，依次排列之后，每次是将空位和相邻位进行调换，研究后会发现，每次调换，逆序数增幅都为偶数，也就是不改变奇偶性，所以只需要根据初始和目标状态的逆序数正负判断即可。估价函数H：是根据与目标解的曼哈顿距离，也就是每个数字与目标位置的曼哈顿距离之和。 #include using namespace

2016-08-11 00:27:41 485

原创 HDU 2181 哈密顿绕行世界问题（搜索）

思路：原来这是个搜索水题.... #include using namespace std; int mp[25][25]; int vis[30]; int ans[30]; int cnt = 1,m; void dfs(int p,int num) { ans[num]=p; if(num==20 && mp[p][m]) { printf("%d: ",cnt++);

2016-08-11 00:24:48 334

原创 POJ - 2411 Mondriaan's Dream（状态压缩DP）

思路：状压DP #include #include #include using namespace std; const int maxn = 12; #define LL long long LL dp[2][(1<<15)]; int path[(1<<12)*(1<<12)][2]; int w; void get(int m) { for(int i = 0;i<

2016-08-10 21:45:01 304

原创 HDU 1412 {A} + {B}（STL）

思路：求集合的并集而不是加法，用一个set随便搞搞就好了 #include using namespace std; int main() { int n,m; while(scanf("%d%d",&n,&m)!=EOF) { sets; int x; for(int i = 1;i<=n;i++) { scanf("%d",&x); s.inser

2016-08-10 16:54:36 350

原创 POJ 3481 Double Queue（STL）

思路：虽然是个SBT的裸题，不过用set也是可以水过的 #include #include #include #include #include using namespace std; int main() { set >s; set >::iterator it; int p,k,n; while(scanf("%d",&n)!=EOF && n) { if(n

2016-08-10 16:53:29 320

原创 HDU 4006 The kth great number（STL）

思路：求第k大的数，k是确定的，那么直接用一个优先队列保留前K个元素就好了 #include using namespace std; int main() { int n,k; while(scanf("%d%d",&n,&k)!=EOF) { priority_queue,greater >q; for (int i = 1;i<=n;i++) { char

2016-08-10 16:52:20 350

原创 HDU 4268 Alice and Bob（贪心+STL）

思路：分析：对Alice 和Bob的牌都按 h 排序，然后对Alice的每张牌，在Bob的牌中找一个最大能覆盖的。也就是说首先满足Alice的牌 h >= Bob的牌 h，然后找最大 w。在查找最大的w时，可以使用multiset中的lower_bound。multiset动态插入每次只插入满足Alice的牌 h >= Bob的牌 h 的牌。 #include #inc

2016-08-10 16:50:52 916

原创 poj1275 Cashier Employment（差分约束）

思路：挺难的一道差分约束见题解：点击打开链接 #include #include #include #include #include using namespace std; const int inf = 0x3f3f3f3f; int r[30], t[30]; int n; struct edge { int v, cost; edge

2016-08-10 14:55:02 522

原创 POJ 2949 Word Rings（差分约束）

思路：找平均值最大的环，将字符串前两个和最后两个当做两个结点，有一条边权值就是这个串的长度。那么avg = (w1+w2+....wk)/k，把k乘过去有avg*k = (w1+w2+...wk)，然后有(w1-avg)+(w2-avg)+...(wk-avg)>=0，然后其实就是要求(w1-ans)+(w2-ans)+...(wk-ans)>0，二分ans然后求正环。

2016-08-10 13:07:28 698

空空如也

空空如也