problem1 link

假设第$i$种出现的次数为$n_{i}$,总个数为$m$,那么排列数为$T=\frac{m!}{\prod_{i=1}^{26}(n_{i}!)}$

然后计算回文的个数,只需要考虑前一半,得到个数为$R$,那么答案为$\frac{R}{T}$.

为了防止数字太大导致越界,可以分解为质因子的表示方法。

problem2 link

假设终点所在的位置为$(tx,ty)$,那么所有底面是$1x1$的格子$(x,y)$一定满足$(x-tx)mod(3)=0,(y-ty)mod(3)=0$

把每个这样的点拆成两个点然后建立最小割的图。

源点与所有的$b$相连,终点与汇点相连,流量为无穷,割边不会在这里产生。

如果不是洞,那么这个格子拆成的两个点流量为1,表示将这个格子设为洞。

每个格子向周围连边,流量为将中间的两个格子设为洞的代价。

最后最小割就是答案。

problem3 link

首先考虑集合之间的关系。设$f[i][j]$表示前$i$个人分成$j$个集合的方案数。初始化$f[1][1]=n$。那么有:

(1)$f[i+1][j+1]=f[i][j]*j$表示新加一个集合,可以在任意两个集合之间

(2)$f[i+1][j]=f[i][j]*j*2$表示新加的元素与之前的某一个集合在一起,可以放在那个集合的前后,所以有$j*2$种方法

(3)$f[i+1][j-1]=f[i][j]*j$表示合并两个集合,可以在任意两个集合之间插入从而进行合并

最后就是对于$f[x][y]$来说,有多少种方式可以在$n$个位置上放置$x$个使得有$y$个集合并且任意两个集合不相邻。令$m=n-(x-y)$,那么相当于在$m$个位置中放置$y$个,使得任意两个不相邻。由于$f[1][1]=n$那么这$y$个集合的排列已经计算了,所以现在可以假设这$y$个元素的第一个放在$m$个位置的第一个位置,那么第二个位置也不能放置了。所以还剩$m-2$个位置,$y-1$个元素。由于每放置一个元素其后面的位置就不能放置了,所以可以把剩下$y-1$个元素的位置与其后面相邻的位置绑定成一个位置,这样的话,就是$m-2-(y-1)$个位置,$y-1$个元素,即$C_{m-2-(y-1)}^{y-1}=C_{n-(x-y)-2-(y-1)}^{y-1}=C_{n-x-1}^{y-1}$

code for problem1

  1. #include <cmath>
  2. #include <string>
  3. #include <vector>
  4.  
  5. class PalindromePermutations {
  6. public:
  7. double palindromeProbability(const std::string &word) {
  8. std::vector<int> h(26, 0);
  9. for (auto e : word) {
  10. ++h[e - 'a'];
  11. }
  12. int old_idx = -1;
  13. for (int i = 0; i < 26; ++i) {
  14. if (h[i] % 2 == 1) {
  15. if (old_idx != -1) {
  16. return 0.0;
  17. }
  18. old_idx = i;
  19. }
  20. }
  21. auto total = Compute(h);
  22. if (old_idx != -1) {
  23. --h[old_idx];
  24. }
  25. for (auto &e : h) {
  26. e /= 2;
  27. }
  28. auto target = Compute(h);
  29. double result = 1.0;
  30. for (int i = 2; i < 50; ++i) {
  31. result *= std::pow(i, target[i] - total[i]);
  32. }
  33. return result;
  34. }
  35.  
  36. private:
  37. std::vector<int> Compute(const std::vector<int> &h) {
  38. std::vector<int> result(50, 0);
  39. auto Add = [&](int x, int sgn) {
  40. for (int i = 2; i <= x; ++i) {
  41. int k = i;
  42. for (int j = 2; j * j <= k; ++j) {
  43. while (k % j == 0) {
  44. result[j] += sgn;
  45. k /= j;
  46. }
  47. }
  48. if (k != 1) {
  49. result[k] += sgn;
  50. }
  51. }
  52. };
  53. int n = 0;
  54. for (auto e : h) {
  55. Add(e, -1);
  56. n += e;
  57. }
  58. Add(n, 1);
  59. return result;
  60. }
  61. };

code for problem2

  1. #include <limits>
  2. #include <unordered_map>
  3. #include <vector>
  4.  
  5. template <typename FlowType>
  6. class MaxFlowSolver {
  7. static constexpr FlowType kMaxFlow = std::numeric_limits<FlowType>::max();
  8. static constexpr FlowType kZeroFlow = static_cast<FlowType>(0);
  9. struct node {
  10. int v;
  11. int next;
  12. FlowType cap;
  13. };
  14.  
  15. public:
  16. int VertexNumber() const { return used_index_; }
  17.  
  18. FlowType MaxFlow(int source, int sink) {
  19. source = GetIndex(source);
  20. sink = GetIndex(sink);
  21.  
  22. int n = VertexNumber();
  23. std::vector<int> pre(n);
  24. std::vector<int> cur(n);
  25. std::vector<int> num(n);
  26. std::vector<int> h(n);
  27. for (int i = 0; i < n; ++i) {
  28. cur[i] = head_[i];
  29. num[i] = 0;
  30. h[i] = 0;
  31. }
  32. int u = source;
  33. FlowType result = 0;
  34. while (h[u] < n) {
  35. if (u == sink) {
  36. FlowType min_cap = kMaxFlow;
  37. int v = -1;
  38. for (int i = source; i != sink; i = edges_[cur[i]].v) {
  39. int k = cur[i];
  40. if (edges_[k].cap < min_cap) {
  41. min_cap = edges_[k].cap;
  42. v = i;
  43. }
  44. }
  45. result += min_cap;
  46. u = v;
  47. for (int i = source; i != sink; i = edges_[cur[i]].v) {
  48. int k = cur[i];
  49. edges_[k].cap -= min_cap;
  50. edges_[k ^ 1].cap += min_cap;
  51. }
  52. }
  53. int index = -1;
  54. for (int i = cur[u]; i != -1; i = edges_[i].next) {
  55. if (edges_[i].cap > 0 && h[u] == h[edges_[i].v] + 1) {
  56. index = i;
  57. break;
  58. }
  59. }
  60. if (index != -1) {
  61. cur[u] = index;
  62. pre[edges_[index].v] = u;
  63. u = edges_[index].v;
  64. } else {
  65. if (--num[h[u]] == 0) {
  66. break;
  67. }
  68. int k = n;
  69. cur[u] = head_[u];
  70. for (int i = head_[u]; i != -1; i = edges_[i].next) {
  71. if (edges_[i].cap > 0 && h[edges_[i].v] < k) {
  72. k = h[edges_[i].v];
  73. }
  74. }
  75. if (k + 1 < n) {
  76. num[k + 1] += 1;
  77. }
  78. h[u] = k + 1;
  79. if (u != source) {
  80. u = pre[u];
  81. }
  82. }
  83. }
  84. return result;
  85. }
  86.  
  87. MaxFlowSolver() = default;
  88.  
  89. void Clear() {
  90. edges_.clear();
  91. head_.clear();
  92. vertex_indexer_.clear();
  93. used_index_ = 0;
  94. }
  95.  
  96. void InsertEdge(int from, int to, FlowType cap) {
  97. from = GetIndex(from);
  98. to = GetIndex(to);
  99. AddEdge(from, to, cap);
  100. AddEdge(to, from, kZeroFlow);
  101. }
  102.  
  103. private:
  104. int GetIndex(int idx) {
  105. auto iter = vertex_indexer_.find(idx);
  106. if (iter != vertex_indexer_.end()) {
  107. return iter->second;
  108. }
  109. int map_idx = used_index_++;
  110. head_.push_back(-1);
  111. return vertex_indexer_[idx] = map_idx;
  112. }
  113.  
  114. void AddEdge(int from, int to, FlowType cap) {
  115. node p;
  116. p.v = to;
  117. p.cap = cap;
  118. p.next = head_[from];
  119. head_[from] = static_cast<int>(edges_.size());
  120. edges_.emplace_back(p);
  121. }
  122.  
  123. std::vector<node> edges_;
  124. std::vector<int> head_;
  125.  
  126. std::unordered_map<int, int> vertex_indexer_;
  127. int used_index_ = 0;
  128. };
  129.  
  130. class BlockTheBlockPuzzle {
  131. static constexpr int kInfinite = 1000000;
  132.  
  133. public:
  134. int minimumHoles(const std::vector<std::string> &S) {
  135. MaxFlowSolver<int> solver;
  136. int n = static_cast<int>(S.size());
  137. int source = -1;
  138. int sink = -2;
  139. int tx = -1, ty = -1;
  140. for (int i = 0; i < n; ++i) {
  141. for (int j = 0; j < n; ++j) {
  142. if (S[i][j] == '$') {
  143. tx = i;
  144. ty = j;
  145. }
  146. }
  147. }
  148.  
  149. auto P0 = [&](int i, int j) { return i * n + j; };
  150. auto P1 = [&](int i, int j) { return i * n + j + n * n; };
  151.  
  152. for (int i = 0; i < n; ++i) {
  153. for (int j = 0; j < n; ++j) {
  154. if (i % 3 == tx % 3 && j % 3 == ty % 3) {
  155. if (S[i][j] == '$') {
  156. solver.InsertEdge(P1(i, j), sink, kInfinite);
  157. }
  158. if (S[i][j] == 'b') {
  159. solver.InsertEdge(source, P0(i, j), kInfinite);
  160. }
  161. if (S[i][j] != 'H') {
  162. solver.InsertEdge(P0(i, j), P1(i, j),
  163. S[i][j] == '.' ? 1 : kInfinite);
  164. }
  165. if (i + 3 < n) {
  166. auto cost = GetCost(S, i + 1, j, i + 2, j);
  167. solver.InsertEdge(P1(i, j), P0(i + 3, j), cost);
  168. solver.InsertEdge(P1(i + 3, j), P0(i, j), cost);
  169. }
  170. if (j + 3 < n) {
  171. auto cost = GetCost(S, i, j + 1, i, j + 2);
  172. solver.InsertEdge(P1(i, j), P0(i, j + 3), cost);
  173. solver.InsertEdge(P1(i, j + 3), P0(i, j), cost);
  174. }
  175. }
  176. }
  177. }
  178. auto result = solver.MaxFlow(source, sink);
  179. if (result >= kInfinite) {
  180. return -1;
  181. }
  182. return result;
  183. }
  184.  
  185. private:
  186. int GetCost(const std::vector<std::string> &s, int x1, int y1, int x2,
  187. int y2) {
  188. if (s[x1][y1] == 'b' || s[x2][y2] == 'b') {
  189. return kInfinite;
  190. }
  191. int ans = 0;
  192. if (s[x1][y1] == '.') {
  193. ++ans;
  194. }
  195. if (s[x2][y2] == '.') {
  196. ++ans;
  197. }
  198. return ans;
  199. }
  200. };

code for problem3

  1. constexpr int kMod = 1000000007;
  2. constexpr int kMax = 2000;
  3.  
  4. int f[kMax + 1][kMax + 1];
  5. int C[kMax + 1][kMax + 1];
  6.  
  7. class Seatfriends {
  8. public:
  9. int countseatnumb(int N, int K, int G) {
  10. f[1][1] = N;
  11. for (int i = 1; i < K; ++i) {
  12. for (int j = 1; j <= G; ++j) {
  13. long long p = f[i][j];
  14. if (p == 0) {
  15. continue;
  16. }
  17. if (j < G) {
  18. (f[i + 1][j + 1] += static_cast<int>(p * j % kMod)) %= kMod;
  19. }
  20. (f[i + 1][j - 1] += static_cast<int>(p * j % kMod)) %= kMod;
  21. (f[i + 1][j] += static_cast<int>(p * 2 * j % kMod)) %= kMod;
  22. }
  23. }
  24. if (K == N) {
  25. return f[K][0];
  26. }
  27.  
  28. C[0][0] = 1;
  29. for (int i = 1; i <= N; ++i) {
  30. C[i][0] = C[i][i] = 1;
  31. for (int j = 1; j < i; ++j)
  32. C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % kMod;
  33. }
  34.  
  35. long long ans = 0;
  36. for (int j = 1; j <= G; ++j) {
  37. ans += static_cast<long long>(f[K][j]) * C[N - K - 1][j - 1] % kMod;
  38. }
  39. return static_cast<int>(ans % kMod);
  40. }
  41. };

topcoder srm 625 div1的更多相关文章

  1. Topcoder SRM 643 Div1 250<peter_pan>

    Topcoder SRM 643 Div1 250 Problem 给一个整数N,再给一个vector<long long>v; N可以表示成若干个素数的乘积,N=p0*p1*p2*... ...

  2. Topcoder Srm 726 Div1 Hard

    Topcoder Srm 726 Div1 Hard 解题思路: 问题可以看做一个二分图,左边一个点向右边一段区间连边,匹配了左边一个点就能获得对应的权值,最大化所得到的权值的和. 然后可以证明一个结 ...

  3. topcoder srm 714 div1

    problem1 link 倒着想.每次添加一个右括号再添加一个左括号,直到还原.那么每次的右括号的选择范围为当前左括号后面的右括号减去后面已经使用的右括号. problem2 link 令$h(x) ...

  4. topcoder srm 738 div1 FindThePerfectTriangle(枚举)

    Problem Statement      You are given the ints perimeter and area. Your task is to find a triangle wi ...

  5. Topcoder SRM 602 div1题解

    打卡- Easy(250pts): 题目大意:rating2200及以上和2200以下的颜色是不一样的(我就是属于那个颜色比较菜的),有个人初始rating为X,然后每一场比赛他的rating如果增加 ...

  6. Topcoder SRM 627 div1 HappyLettersDiv1 : 字符串

    Problem Statement      The Happy Letter game is played as follows: At the beginning, several players ...

  7. topcoder SRM 625 DIV2 IncrementingSequence

    由于题目数据量比较小,故可以开辟一个数组存储每个index出现的次数 然后遍历即可 string canItBeDone(int k, vector<int> A){ vector< ...

  8. topcoder SRM 625 DIV2 AddMultiply

    由于题目告诉肯定至少存在一种解, 故只需要根据条件遍历一下, vector <int> makeExpression(int y) { vector<int> res; ; i ...

  9. Topcoder SRM 584 DIV1 600

    思路太繁琐了 ,实在不想解释了 代码: #include<iostream> #include<cstdio> #include<string> #include& ...

随机推荐

  1. Express全系列教程之(八):session的基本使用

    一.关于session session是另一种记录客户状态的机制,与cookie保存在客户端浏览器不同,session保存在服务器当中:当客户端访问服务器时,服务器会生成一个session对象,对象中 ...

  2. 新手上路、安装JDK教程

    按照以下的图片步骤,登录http://www.oracle.com 下载 JDK (J2SE)  JDK 1.0, 1.1, 1.2, 1.3, 1.4    1.5.(JDK5.0) → 支持注解. ...

  3. 【Linux】Mac Centos install VMware Tools

    can't use yum: vi /etc/sysconfig/network-scripts/ifcfg-enp4s0 yum -y install lshw pciutils gdisk sys ...

  4. win 下 python ImportError: No module named requests

    第一次弄爬虫,报库找不到,网上找了半天,一般都让都让改成绝对路径...那不是饮鸩止渴嘛. 然后 在无意中发现,不需要控制台输入pip命令,因为不是在Linux下啊,,win下直接在pycharm里添加 ...

  5. .htaccess使用方法介绍

    1..htaccess文件使用前提 .htaccess的主要作用就是实现url改写,也就是当浏览器通过url访问到服务器某个文件夹时,作为主人,我们可以来接待这个url,具体地怎样接待它,就是此文件的 ...

  6. 我的第三篇博客(激动激动真激动!!!)A-B Problem

    #210. 差(A-B problem) 题目描述 楠楠在网上刷题,感觉第一题:求两数的和(A+B Problem)太无聊了,于是增加了一题:A-B Problem,难倒了一群小朋友,哈哈. 题目是这 ...

  7. Sublime 个人常用快捷键

    Sublime 个人常用快捷键 Hot Key Alt + F3 选中文本所以有相同项;同多次Ctrl + D Ctrl + L 选中整行,继续按可继续选 Ctrl + Shift + M 选择括号内 ...

  8. Linux 7.x 防火墙&端口

    Linux 7.x 防火墙&端口 查看当前防火墙的状态: # firewall-cmd --state 也可以使用指令:systemctl status firewall.service 启动 ...

  9. Go 初体验 - 并发与锁.1 - sync.Mutex 与 sync.RWMutex

    ==== Mutex为互斥锁,顾名思义,被Mutex锁住的代码同时只允许一个协程访问,其它协程进来就要排队 如何使用?看代码: 输出: 释义: 并发1000个协程同时更改m的元素,这样会有一部分更改成 ...

  10. HTTP协议基础总结

    1,HTTP协议协议的概念:协议就是指计算机网络中,两台计算机之间进行通讯所必须共同遵守的规定和规则.HTTP协议:超文本传输协议是一种通信协议,它允许将超文本标记语言(html)文档从web服务器传 ...