1. #include<bits/stdc++.h>
  2. using namespace std;
  3. const int SIZE = 100;
  4. int n,i,j,max_f,ans;
  5. int main(){
  6.     cin >> n;
  7.     for(i = 1 ; i <= n ; i++){
  8.         cin >> x[i] >> y[i];
  9.     }
  10.     max_f = 0;
  11.     for(i = 1 ; i <= n ; i ++){
  12.         f[i] = 0;
  13.         for(j = 1 ; j <= n ; j ++){
  14.             if(x[j] < x[i] && y[j] < y[i]){
  15.                 f[i] = y[i];
  16.             }
  17.         }
  18.         if(f[i] <= max_f){
  19.             max_f = f[i];
  20.             ans = i;
  21.         }
  22.     }
  23.     for(i = 1 ; i <= n ; i ++){
  24.         cout << f[i] << endl;
  25.     }
  26.     cout << ans << endl;
  27.     return 0;
  28. }
  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. const int dayNum[] = {-1,31,28,31,30,31,31,30,31,30,31};
  4. int m,offset,i;
  5. int main(){
  6.     cin >> m;
  7.     cout << "S\tM\tT\tW\tT\tW\tS" << endl;
  8.     offset = 3;
  9.     for(i = 1 ; i < m ; i ++){
  10.         offset = (offset+dayNum)%7;
  11.     }
  12.     for(i = 1 ; i < offset ; i ++){
  13.         cout << '\t';
  14.     }
  15.     for(i =1 ; i < dayNum[m] ; i ++){
  16.         cout << i;
  17.         if(i == dayNum[m] || (offset + i)){
  18.             cout << endl;
  19.         }else{
  20.             cout << '\t';
  21.         }
  22.     }
  23.     return 0;
  24. }

给定两个数组，找出b数组中包含的数

  1. int main(){
  2.     int n,m;
  3.     cin >> n >> m;
  4.     for(int i = 1 ; i <= n ; i ++){
  5.         cin >> arr[i];
  6.     }
  7.     for(int i = 1 ; i <= m ; i ++){
  8.         cin >> brr[i];
  9.     }
  10.     sort(arr+1,arr+1+n);
  11.     sort(brr+1,brr+1+m);
  12.     for(int i = 1 ; i <= m ; i ++){
  13.         if(binary_search(brr[i])){
  14.             cout << brr[i] << " ";
  15.         }
  16.     }
  17.     return 0;
  18. }

[USACO05FEB] 进击的奶牛 Aggressive Cows G

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int a[10005];
  4. int b[10005];
  5. int n,m;
  6. int binary_search(int x){
  7.     int l = 0, r = n + 1;
  8.     if(a[1] > x || a[n]<x){
  9.         return -1;
  10.     }
  11.     while(l + 1 != r){
  12.         int mid = (l+r) >> 1;
  13.         if(a[mid] < x) r = mid;
  14.         else if(mid < x) l = mid;
  15.     }
  16.     if(a[r] == x) return r;
  17.     else return -1;
  18. }
  19. int main(){
  20.     cin >> n >> m;
  21.     for(int i = 1 ; i <= n ; i ++){
  22.         cin >> a[i];
  23.     }
  24.     for(int i = 1 ; i <= m ; i ++){
  25.         cin >> b[i];
  26.     }
  27.     sort(a+1,a+1+n);
  28.     sort(b+1,b+1+m);
  29.     for(int i = 1 ; i <= m ; i ++){
  30.         if(binary_search(b[i])){
  31.             cout << b[i] << " ";
  32.         }
  33.     }
  34.     return 0;
  35. }

方阵填数

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int a[10][10];
  4. void f(int x,int y , int k){
  5.     a[x][y] = k;
  6.     if(y+1 <= 4 && a[x][y+1] == 0){
  7.         f(x,y+1,k+1);
  8.     }
  9.     if(x+1 <= 4 && a[x+1][y] == 0){
  10.         f(x+1,y,k+1);
  11.     }
  12.     if(y-1 >= 1 && a[x][y-1] == 0){
  13.         f(x,y-1,k+1);
  14.     }
  15.     if(x-1 >= 1 && a[x-1][y] == 0){
  16.         f(x-1,y,k+1);
  17.     }
  18. }
  19. int main(){
  20.     f(1,1,1);
  21.     for(int i = 1 ; i <= 4 ; i ++){
  22.         for(int j = 1 ; j <= 4 ; j ++){
  23.             cout << setw(5) <<a[i][j];
  24.         }
  25.         cout << endl;
  26.     }
  27. }

深搜基础框架

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int n;
  4. char a[10][10];
  5. int path[410][3];
  6. void print(int k){
  7.     for(int i = 1 ; i <= k ; i ++){
  8.         cout << "(" << path[i][1] << "," << path[i][2] << ")";
  9.         if(i != k){
  10.             cout << "->";
  11.         }
  12.     }
  13. }
  14. void dfs(int x,int y , int k){
  15.     path[k][1] = x;
  16.     path[k][2] = y;
  17.     a[x][y] = '1';
  18.     if(x == n && y == n){
  19.         print(k);
  20.     }
  21.     if(a[x][y+1] == '0'){
  22.         dfs(x,y+1,k+1);
  23.     }
  24.     if(a[x+1][y] == '0'){
  25.         dfs(x+1,y,k+1);
  26.     }
  27.     if(a[x][y-1] == '0'){
  28.         dfs(x,y-1,k+1);
  29.     }
  30.     if(a[x-1][y] == '0'){
  31.         dfs(x-1,y,k+1);
  32.     }
  33. }
  34. int main(){
  35.     cin >> n;
  36.     for(int i = 1 ; i <= n ; i ++){
  37.         for(int j = 1 ; j <= n ; j ++){
  38.             cin >> a[i][j];
  39.         }
  40.     }
  41.     dfs(1,1,1);
  42. }
  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int n = 0 ;
  4. bool mark[6][6];
  5. int path[26][3];
  6. int count;
  7. int dx[5] = {0,0,1,0,-1};
  8. int dy[5] = {0,1,0,-1,0};
  9. void print_path(int k){
  10.     for(int i = 1 ; i < k ; i ++){
  11.         cout << path[i][1] << "," << path[i][2] << "->";
  12.     }
  13.     cout << path[k][1] << "," << path[k][2] << endl;
  15. }
  16. void dfs(int x,int y , int k){
  17.     path[k][1] = x;
  18.     path[k][2] = y;
  19.     if(x == n && y == n){
  20.         print_path(k);
  21.         return;
  22.     }
  23.     for(int i = 1 ; i <= 4 ; i++){
  24.         int tx = x + dx[i];
  25.         int ty = y + dy[i];
  26.         if(mark[tx][ty] == false && tx >= 1 && tx <= n && tx <= n && ty <= n){
  27.             mark[tx][ty] = true;
  28.             dfs(tx,ty,k+1);
  29.             mark[tx][ty] = false;
  30.             path[k+1][1] = 0;
  31.             path[k+1][2] = 0;
  32.         }
  33.     }
  34. }
  35. int main(){
  36.     cin >> n; // 3
  37.     mark[1][1] = true ;
  38.     dfs(1,1,1); // mark的行、mark的列、path的行
  39. }
  2. // #include<bits/stdc++.h>
  3. // using namespace std;
  4. // const int SIZE = 100;
  5. // int main(){
  6. //     int n , i , sum,x,a[SIZE];
  7. //     cin >> n;
  8. //     memset(a,0,sizeof(a));for(i = 1 ; i <= n ; i ++){
  9. //         cin >> x ;
  10. //         a[x] ++;
  11. //     }
  12. //     i = 0;
  13. //     sum = 0;
  14. //     while(sum < (n/2+1)){
  15. //         i ++;
  16. //         sum += a[i];
  17. //     }
  18. //     cout << i << endl;
  19. //     return 0;
  20. // }
  21. // #include<bits/stdc++.h>
  22. // using namespace std;
  23. // int main(){
  24. //     int a[6] = {1,2,3,4,5,6};
  25. //     int pi = 0;
  26. //     int pj = 5 ; 
  27. //     int t,i;
  28. //     while (pi < pj){
  29. //         t=a[pi];
  30. //         a[pi] = a[pj];
  31. //         a[pj] = t;
  32. //         pi ++;
  33. //         pj --;
  34. //     }
  35. //     for(i = 0 ; i < 5 ; i ++){
  36. //         cout << a[i] << ",";
  37. //     }
  38. //     cout << a[5];
  39. //     cout << endl;
  40. //     return 0;
  41. // }
  42. // #include<bits/stdc++.h>
  43. // using namespace std;
  44. // int arr[9] = {11,22,66,77,33,55,44,88};
  45. // int brr[9];
  46. // void merge(int l , int mid , int r){
  47. //     int i = l ; 
  48. //     int k = l;
  49. //     int j = mid + 1 ;
  50. //     while((i <= mid) && (j <=r)){
  51. //         if(arr[i] >arr[j]){
  52. //             brr[k++] = arr[i++];
  53. //         }else{
  54. //             brr[k++] = arr[j++];
  55. //         }
  56. //     }
  57. //     if(i <= mid){
  58. //         for(k = i ; k < mid ; k++){
  59. //             cout << arr[k]<< ' ';
  60. //         }
  61. //     }else{
  62. //         for(k = j ; k < r ; k++){
  63. //             cout << brr[k]<< ' ';
  64. //         }
  65. //     }
  66. //     while(i <= mid){
  67. //         brr[k++] = arr[i++];n
  68. //     }
  69. //     while(j <= r){
  70. //         brr[k++] = arr[j++];
  71. //     }
  72. //     for (int i = l ; i <= r ; i ++){
  73. //         arr[i] = brr[i];
  74. //     }
  75. // }
  76. // void mergeSort(int l , int r){
  77. //     if(l >= r) return ;
  78. //     int mid = (l+r)/2;
  79. //     mergeSort(l,mid);
  80. //     mergeSort(mid+1 , r);
  81. //     merge(l,mid,r);
  82. // }
  83. // int main(){
  84. //     mergeSort(1,8);
  85. //     return 0;
  86. // }
  89. // #include<bits/stdc++.h>
  90. // using namespace std;
  91. // long long a[60] = {0};
  92. // a[1] = 1;
  93. // a[2] = 1;
  94. // int tz(long long x){
  95. //     if(a[x] != 0){
  96. //         return a[x];
  97. //     }else{
  98. //         a[x] = tz(x-1) + tz(x-2);
  99. //         return a[x];
  100. //     }
  102. // }
  103. // int main(){
  105. // }
  107. // #include<bits/stdc++.h>
  108. // using namespace std;
  109. // int a[10][10];
  110. // void f(int x,int y , int k){
  111. //     a[x][y] = k;
  112. //     if(y+1 <= 4 && a[x][y+1] == 0){
  113. //         f(x,y+1,k+1);
  114. //     }
  115. //     if(x+1 <= 4 && a[x+1][y] == 0){
  116. //         f(x+1,y,k+1);
  117. //     }
  118. //     if(y-1 >= 1 && a[x][y-1] == 0){
  119. //         f(x,y-1,k+1);
  120. //     }
  121. //     if(x-1 >= 1 && a[x-1][y] == 0){
  122. //         f(x-1,y,k+1);
  123. //     }
  124. // }
  125. // int main(){
  126. //     f(1,1,1);
  127. //     for(int i = 1 ; i <= 4 ; i ++){
  128. //         for(int j = 1 ; j <= 4 ; j ++){
  129. //             cout << setw(5) <<a[i][j];
  130. //         }
  131. //         cout << endl;
  132. //     }
  133. // }
  135. // #include<bits/stdc++.h>
  136. // using namespace std;
  137. // int n;
  138. // char a[10][10];
  139. // int path[410][3];
  140. // void print(int k){
  141. //     for(int i = 1 ; i <= k ; i ++){
  142. //         cout << "(" << path[i][1] << "," << path[i][2] << ")";
  143. //         if(i != k){
  144. //             cout << "->";
  145. //         }
  146. //     }
  148. // }
  149. // void dfs(int x,int y , int k){
  150. //     path[k][1] = x;
  151. //     path[k][2] = y;
  152. //     a[x][y] = '1';
  153. //     if(x == n && y == n){
  154. //         print(k);
  155. //     }
  156. //     if(a[x][y+1] == '0'){
  157. //         dfs(x,y+1,k+1);
  158. //     }
  159. //     if(a[x+1][y] == '0'){
  160. //         dfs(x+1,y,k+1);
  161. //     }
  162. //     if(a[x][y-1] == '0'){
  163. //         dfs(x,y-1,k+1);
  164. //     }
  165. //     if(a[x-1][y] == '0'){
  166. //         dfs(x-1,y,k+1);
  167. //     }
  168. // }
  169. // int main(){
  170. //     cin >> n;
  171. //     for(int i = 1 ; i <= n ; i ++){
  172. //         for(int j = 1 ; j <= n ; j ++){
  173. //             cin >> a[i][j];
  174. //         }
  175. //     }
  176. //     dfs(1,1,1);
  177. // }
  179. // #include<bits/stdc++.h>
  180. // using namespace std;
  181. // int n = 0 ;
  182. // bool mark[6][6];
  183. // int path[26][3];
  184. // int count;
  185. // int dx[5] = {0,0,1,0,-1};
  186. // int dy[5] = {0,1,0,-1,0};
  187. // void print_path(int k){
  188. //     for(int i = 1 ; i < k ; i ++){
  189. //         cout << path[i][1] << "," << path[i][2] << "->";
  190. //     }
  191. //     cout << path[k][1] << "," << path[k][2] << endl;
  193. // }
  194. // void dfs(int x,int y , int k){
  195. //     path[k][1] = x;
  196. //     path[k][2] = y;
  197. //     if(x == n && y == n){
  198. //         print_path(k);
  199. //         return;
  200. //     }
  201. //     for(int i = 1 ; i <= 4 ; i++){
  202. //         int tx = x + dx[i];
  203. //         int ty = y + dy[i];
  204. //         if(mark[tx][ty] == false && tx >= 1 && tx <= n && tx <= n && ty <= n){
  205. //             mark[tx][ty] = true;
  206. //             dfs(tx,ty,k+1);
  207. //             mark[tx][ty] = false;
  208. //             path[k+1][1] = 0;
  209. //         }
  210. //     }
  211. // }
  212. // int main(){
  213. //     cin >> n; // 3
  214. //     mark[1][1] = true ;
  215. //     dfs(1,1,1); // mark的行、mark的列、path的行
  216. // }
  218. #include<bits/stdc++.h>
  219. using namespace std;
  220. int n;
  221. int a[1000005];
  222. void quickSort(int left , int right){
  223.     if(left >= right){
  224.         return;
  225.     }
  226.     int i = left;
  227.     int j = right;
  228.     int mid = (left + right) / 2 ; 
  229.     int p = a[mid];
  230.     while (left <= right){
  231.         while(a[i] < p){
  232.             i++;
  233.         }
  234.         while(a[j] > p){
  235.             j--;
  236.         }
  237.         if(i <= j){
  238.             swap(a[i] ,a[j]);
  239.             i ++;
  240.             j --;
  241.         }
  242.     }
  243.     if(left < j)quickSort(left,j);
  244.     if(i < right) quickSort(i , right);
  245. }
  246. int main(){
  247.     cin >> n;
  248.     int mid = 0;
  249.     for(int i = 0 ; i < n ; i ++){
  250.         cin >> a[i];
  251.     }
  252.     quickSort(0,n-1);
  253.     for(int i = 0 ; i < n ; i ++){
  254.         cout << a[i] << ' ';
  255.     }
  256. }