hdu 2018 多校 第五场

1002 小洛洛

开场挂了N发插入排序的我( 最后还是要靠小洛洛写暴力

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <iostream>
 4 #include <cmath>
 5 #include <cstdlib>
 6 #include <algorithm>
 7 using namespace std;
 8
 9 const int N = 12;
10
11 int min_(char s[], int mul, int k, bool fst = false) {
12   if(!*s)
13     return 0;
14   char x = *s;
15   if(k)
16     for(char *p = s; *p; ++p)
17       if(!fst || *p != ‘0‘)
18         x = min(x, *p);
19   int mn = 1000000000;
20   if(*s == x)
21     mn = min_(s + 1, mul / 10, k);
22   else
23     for(char *p = s + 1; *p; ++p)
24       if(*p == x) {
25         swap(*s, *p);
26         mn = min(mn, min_(s + 1, mul / 10, k - 1));
27         swap(*s, *p);
28       }
29   return (x - ‘0‘) * mul + mn;
30 }
31 int max_(char s[], int mul, int k) {
32   if(!*s)
33     return 0;
34   char x = *s;
35   if(k)
36     for(char *p = s; *p; ++p)
37       x = max(x, *p);
38   int mx = 0;
39   if(*s == x)
40     mx = max_(s + 1, mul / 10, k);
41   else
42     for(char *p = s + 1; *p; ++p)
43       if(*p == x) {
44         swap(*s, *p);
45         mx = max(mx, max_(s + 1, mul / 10, k - 1));
46         swap(*s, *p);
47       }
48   return (x - ‘0‘) * mul + mx;
49 }
50
51 int main() {
52   int t;
53   scanf("%d", &t);
54   while(t--) {
55     int k;
56     char s[N];
57     scanf("%s%d", s, &k);
58     int mul = 1;
59     for(char *p = s + 1; *p; ++p)
60       mul *= 10;
61     int mn = min_(s, mul, k, true);
62     int mx = max_(s, mul, k);
63     printf("%d %d\n", mn, mx);
64   }
65   return 0;
66 }

1005 BPM136

用圆的面积交模板改一下就好了

 1 /* ***********************************************
 2 Author        :BPM136
 3 Created Time  :2018/8/6 12:38:56
 4 File Name     :1005.cpp
 5 ************************************************ */
 6
 7 #include<iostream>
 8 #include<cstdio>
 9 #include<algorithm>
10 #include<cstdlib>
11 #include<cmath>
12 #include<cstring>
13 #include<vector>
14 using namespace std;
15
16 const int N = 105;
17 const double pi = acos(-1.0);
18
19 struct point {
20     double x,y;
21 };
22
23 struct circle {
24     int x,y;
25     int R;
26 }c[N];
27 int m,R;
28
29 double cirinter(int r1,int x2,int y2,int r2) {
30     double d,s,t,a1,a2,s1,s2,s3;
31     d=sqrt((-x2)*(-x2)+(-y2)*(-y2));
32     if(d>=r1+r2)return 0;
33     else if(d<r1-r2) return 0;
34     else
35     {
36         a1=acos((r1*r1+d*d-r2*r2)/(2*r1*d));
37         a2=acos((r2*r2+d*d-r1*r1)/(2*r2*d));
38         s1=2*a1*r1;
39         s2=2*a2*r2;
40         s=s2-s1;
41     }
42     return s;
43 }
44
45 int main() {
46     int T;
47     scanf("%d",&T);
48     while(T--) {
49         scanf("%d%d",&m,&R);
50         for(int i=1;i<=m;i++) scanf("%d%d%d",&c[i].x,&c[i].y,&c[i].R);
51         double ans=2*pi*R;
52         for(int i=1;i<=m;i++) ans+=cirinter(R,c[i].x,c[i].y,c[i].R);
53         printf("%.10f\n",ans);
54     }
55     return 0;
56 }

1007 BPM136

正解st表下压待补

线段树据说势能分析一下是对的?

线段树版本

 1 /* ***********************************************
 2 Author        :BPM136
 3 Created Time  :2018/8/6 17:45:43
 4 File Name     :1007G.cpp
 5 ************************************************ */
 6
 7 #include<iostream>
 8 #include<cstdio>
 9 #include<algorithm>
10 #include<cstdlib>
11 #include<cmath>
12 #include<cstring>
13 #include<vector>
14 using namespace std;
15
16 typedef unsigned int UI;
17 typedef long long ll;
18
19 UI X,Y,Z;
20
21 UI RNG61() {
22     X=X^(X<<11);
23     X=X^(X>>4);
24     X=X^(X<<5);
25     X=X^(X>>14);
26     UI W=X^(Y^Z);
27     X=Y;
28     Y=Z;
29     Z=W;
30     return Z;
31 }
32
33 const int N = 100005;
34 const unsigned int MOD = (1U<<30);
35
36 int n,m;
37
38 #define LSON (k<<1)
39 #define RSON (k<<1|1)
40 #define MID ((l+r)>>1)
41
42 int mx[N<<2];
43
44 void update(int k,int l,int r,int ll,int rr,int val) {
45     if(mx[k]>=val) return ;
46     if(l==ll && r==rr) {
47         mx[k]=val;
48         return ;
49     }
50     int mid=MID;
51     if(rr<=mid) update(LSON,l,mid,ll,rr,val);
52     else if(ll>mid) update(RSON,mid+1,r,ll,rr,val);
53     else {
54         update(LSON,l,mid,ll,mid,val);
55         update(RSON,mid+1,r,mid+1,rr,val);
56     }
57 }
58
59 int query(int k,int pos) {
60     int l=1,r=n;
61     int ret=0;
62     while(l!=r) {
63         ret=max(ret,mx[k]);
64         int mid=MID;
65         if(pos<=mid) {
66             r=mid;
67             k=LSON;
68         } else {
69             l=mid+1;
70             k=RSON;
71         }
72     }
73     ret=max(ret,mx[k]);
74     return ret;
75 }
76
77 int main() {
78     int T;
79     cin>>T;
80     while(T--) {
81         cin>>n>>m>>X>>Y>>Z;
82         memset(mx,0,sizeof(mx));
83         for(int i=1;i<=m;i++) {
84             UI x=RNG61();
85             UI y=RNG61();
86             UI w=RNG61();
87             UI l,r,v;
88             l=min(x%n+1, y%n+1);
89             r=max(x%n+1, y%n+1);
90             while(w>MOD) w-=MOD;
91             update(1,1,n,l,r,w);
92         }
93         ll ans=0;
94         //for(int i=1;i<=n;i++) cerr<<query(1,i)<<‘ ‘; cerr<<endl;
95         for(int i=1;i<=n;i++) ans=ans^((ll)query(1,i)*i);
96         cout<<ans<<endl;
97     }
98     return 0;
99 }

1008 小洛洛

dp 枚举翻转的值域dp就好了

  1 #include <cstdio>
  2 #include <cstring>
  3 #include <iostream>
  4 #include <cmath>
  5 #include <cstdlib>
  6 #include <algorithm>
  7 using namespace std;
  8
  9 template<int BI, int BO>
 10 struct IO_ {
 11     char bufi[BI + 1], *qi, bufo[BO], *qo;
 12     IO_(): qi(bufi + BI), qo(bufo) {}
 13     ~IO_() { o_(EOF); }
 14     int i_() {
 15         if(qi == bufi + BI) bufi[fread(bufi, 1, BI, stdin)] = ‘\0‘, qi = bufi;
 16         return *qi ? *qi++ : EOF;
 17     }
 18     void o_(int c) {
 19         if(c != EOF) *qo++ = c;
 20         if(qo == bufo + BO || (c == EOF && qo != bufo))
 21             fwrite(bufo, qo - bufo, 1, stdout), qo = bufo;
 22     }
 23     IO_ &operator>>(int &ret) {
 24         ret = 0; int c;
 25         while(isspace(c = i_()));
 26         bool bm = c == ‘-‘ ? (c = i_(), true) : false;
 27         while(ret = ret * 10 - (c - ‘0‘), isdigit(c = i_()));
 28         if(!bm) ret = -ret;
 29         return *this;
 30     }
 31     IO_ &operator>>(char *p) {
 32         int c; while(isspace(c = i_()));
 33         do *p++ = c; while(!isspace(c = i_()));
 34         *p = ‘\0‘;
 35         return *this;
 36     }
 37     IO_ &operator<<(char c) { return o_(c), *this; }
 38     IO_ &operator<<(char *p) { while(*p) o_(*p++); return *this; }
 39     IO_ &operator<<(int x) {
 40         char s[12] = {}, *p = s + 11;
 41         bool bm = x < 0 ? true : (x = -x, false);
 42         while(*--p = ‘0‘ - x % 10, x /= 10);
 43         if(bm) *--p = ‘-‘;
 44         while(*p) o_(*p++);
 45         return *this;
 46     }
 47 };
 48
 49 const int N = 100002;
 50 char s[N];
 51 int l[N][10], r[N][10];
 52 int f[N][10][2];
 53
 54 void init_(int n) {
 55   for(int i = 0; i < n; ++i)
 56     for(int j = 0; j <= 9; ++j)
 57       l[i][j] = max(j ? l[i][j - 1] : 0, (i ? l[i - 1][j] : 0) + (j == s[i]));
 58   for(int i = n - 1; i >= 0; --i)
 59     for(int j = 9; j >= 0; --j)
 60       r[i][j] = max(j + 1 <= 9 ? r[i][j + 1] : 0, (i + 1 < n ? r[i + 1][j] : 0) + (j == s[i]));
 61 }
 62
 63 int main() {
 64   auto &io = *new IO_<0x10000, 0x10000>;
 65
 66   int t;
 67   io >> t;
 68   while(t--) {
 69     int n;
 70     io >> n >> s;
 71     for(int i = 0; i < n; ++i)
 72       s[i] -= ‘0‘;
 73
 74     init_(n);
 75
 76     int ans = 1, ansl = 0, ansr = 0;
 77     for(int a = 0; a <= 9; ++a)
 78       for(int b = a; b <= 9; ++b)
 79         for(int i = 0; i < n; ++i) {
 80           int cl = i ? l[i - 1][a] : 0;
 81           int cr = i + 1 < n ? r[i + 1][b] : 0;
 82           for(int j = b; j >= a; --j) {
 83             f[i][j][0] = ~0x7FFFFFFF, f[i][j][1] = -1; // must not be ans
 84             if(j < b)
 85               f[i][j][0] = f[i][j + 1][0], f[i][j][1] = f[i][j + 1][1];
 86             if(i > 0 && f[i - 1][j][0] + (j == s[i]) > f[i][j][0])
 87               f[i][j][0] = f[i - 1][j][0] + (j == s[i]), f[i][j][1] = f[i - 1][j][1];
 88             if(j == s[i] && cl + 1 > f[i][j][0])
 89               f[i][j][0] = cl + 1, f[i][j][1] = i;
 90             int cur = f[i][j][0] + cr;
 91             if(cur > ans) {
 92               ans = cur;
 93               ansl = f[i][j][1];
 94               ansr = i;
 95             }
 96           }
 97         }
 98     io << ans << ‘ ‘ << ansl + 1 << ‘ ‘ << ansr + 1 << ‘\n‘;
 99   }
100
101   delete &io;
102   return 0;
103 }

原文地址:https://www.cnblogs.com/MyGirlfriends/p/9442004.html

时间: 2024-10-07 00:25:51

hdu 2018 多校 第五场的相关文章

2014多校第五场1010 || HDU 4920 Matrix multiplication(矩阵乘法优化)

题目链接 题意 : 给你两个n*n的矩阵,然后两个相乘得出结果是多少. 思路 :一开始因为知道会超时所以没敢用最普通的方法做,所以一直在想要怎么处理,没想到鹏哥告诉我们后台数据是随机跑的,所以极端数据是不可能会有的,而我们一开始一直在想极端数据能接受的方法......后来看了鹏哥的做法,就是把是0的地方都跳过就可以了,用矩阵保存前一个非0数的位置是多少.二师兄给我看了一个代码,人家根本没用别的优化,直接将最里层k的循环提到了最外层,然后就AC了,对此我表示无语. 1 #include <cstd

2014 HDU多校弟五场J题 【矩阵乘积】

题意很简单,就是两个大矩阵相乘,然后求乘积. 用 Strassen算法 的话,当N的规模达到100左右就会StackOverFlow了 况且输入的数据范围可达到800,如果变量还不用全局变量的话连内存开辟都开不出来 1 #pragma comment(linker, "/STACK:16777216") 2 #include <iostream> 3 #include <stdio.h> 4 #define ll long long 5 using namesp

2014多校第五场1001 || HDU 4911 Inversion (归并求逆序数)

题目链接 题意 : 给你一个数列,可以随意交换两相邻元素,交换次数不超过k次,让你找出i < j 且ai > aj的(i,j)的对数最小是多少对. 思路 : 一开始想的很多,各种都想了,后来终于想出来这根本就是求逆序数嘛,可以用归并排序,也可以用树状数组,不过我们用树状数组做错了,也不知道为什么.求出逆序数来再减掉k次,就可以求出最终结果来了.求逆序数链接1,链接2 1 #include <stdio.h> 2 3 int left[250003], right[250003];

2014 HDU多校弟五场A题 【归并排序求逆序对】

这题是2Y,第一次WA贡献给了没有long long 的答案QAQ 题意不难理解,解题方法不难. 先用归并排序求出原串中逆序对的个数然后拿来减去k即可,如果答案小于0,则取0 学习了归并排序求逆序对的方法,可以拿来当模板 TVT 贴代码了: 1 #include <stdio.h> 2 #include <string.h> 3 #include <stdlib.h> 4 #include <math.h> 5 #include <iostream&g

多校第五场 归并排序

HDU 4911 Inversion 考点:归并排序 思路:这题呀比赛的时候忘了知道可以用归并排序算出逆序数,但是忘了归并排序的实质了,然后不会做-- 因为看到题上说是相邻的两个数才能交换的时候,感觉归并排序好像不是得要相邻的呀,然后就这样晕--刚才重新看了才发现,归并就是相邻的交换的,正好是用来求逆序数的,唉--真的是做这个归并排序比赛就来了--真好! #include<iostream> #include<cstdio> #include<cstring> #inc

2019 湖南多校第五场题解

解题过程 开场byf去修锅,各种spj没写,还有写挂的.开场shl写A,lfw写K,shl写E,shl写G,前期签到顺利.随后lfw推出D的规律,开始写,遇到了一些错误,首先MLE了,因为k^2预处理,lfw用的string来存不同的子串丢到unordered_map里,那么就是k^3的存储,肯定炸,接着换成了hash值,但是单关键字冲突了,WA了一发,接着用双关键字,使用一个pair存map,map带的logn常数MLE了一发,中间B题加上了spj,lfw习惯性输出空格,WA一发后过了,最后l

hdu 6088 Rikka with Rock-paper-scissors (2017 多校第五场 1004) 【组合数学 + 数论 + 模意义下的FFT】

题目链接 首先利用组合数学知识,枚举两人的总胜场数容易得到 这还不是卷积的形式,直接搞的话复杂度大概是O(n^2)的,肯定会TLE.但似乎和卷积有点像?想半天没想出来..多谢Q巨提醒,才知道可以用下面这个公式进行转化 最后,化得的公式为 另外注意,上式右边是一个卷积的形式,但是,所得和的第一项是不需要加上的(不过图中公式没有体现).结合实际意义大概就是,i==0&&j==0时,gcd(i,j)不存在约数d,虽然0可以被任意正整数整除 & 第一项不为0 #include<bit

2018多校第十场 HDU 6430 线段树合并

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=6430 题意:一棵树上每个节点权值为v[i],每个节点的heard值是:以它为LCA的两个节点的GCD的最大值,要求输出每个节点的heard值. 题解:权值范围是[1, 1e5],1e5内数因子最多不超过200个,对每个点建一颗线段树,维护每个点的因子,dfs过程中由下往上合并线段树并更新答案. 1 #include <bits/stdc++.h> 2 using namespace std; 3

hdu 4915 Parenthese sequence 多校第五场

推断一个序列是否是有效是简单的. 可是推断序列是不是有多个解会出问题. 那么从i=0 ~l 假设读到问号,推断该问号成为(能否有效,该问号为)是否有效. 假设都有效,则必有多个解. 假设都无效,则无解. 假设一个有效,则把问号改成有效的括号. 代码实现例如以下 #include<stdio.h> #include<string.h> char s[1000005],tp[1000005]; int l; int pd() { int zuo,you,num,i; num=0; zu