BZOJ NOI十连测 第二测 T1

 

出题人居然是个哲学家。。

26%的程序,太SB了。。。本来我的想法也是二分+贪心,但是贪心是个怪怪的SX贪心。。

  1 #include<algorithm>
  2 #include<cstdio>
  3 #include<cmath>
  4 #include<cstring>
  5 #include<iostream>
  6 #include<time.h>
  7 #define inf 0x7fffffff
  8 struct edge{
  9     int u,v,id;
 10 }e[400005];
 11 int tot,go[400005],first[200005],next[400005];
 12 int Tot,Go[400005],First[200005],Next[400005];
 13 int c[200005],b[200005],son[200005],ans,vis[200005],pd;
 14 int pass[400005],op[400005],C[400005],Cnt,block,sum,B[200005];
 15 int id1,id2;
 16 int n,k;
 17 int read(){
 18     char ch=getchar();int t=0,f=1;
 19     while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
 20     while ('0'<=ch&&ch<='9'){t=t*10+ch-'0';ch=getchar();}
 21     return t*f;
 22 }
 23 void Dfs(int x,int fa){
 24     if (vis[x]) return;
 25     c[x]=b[x];son[x]=1;
 26     for (int i=first[x];i;i=next[i]){
 27         int pur=go[i];
 28         if (pur==fa) continue;
 29         if (pass[i]) continue;
 30         Dfs(pur,x);
 31         son[x]+=son[pur];
 32         c[x]+=c[pur];
 33     }
 34     if (c[x]&&(n-c[x]>0)) ans=std::min(ans,std::max(son[x],n-son[x]));
 35 }
 36 void sbpianfen(){
 37     ans=inf;
 38     Dfs(1,0);
 39     printf("%d\n",ans);
 40 }
 41 void insert(int x,int y){
 42     tot++;
 43     go[tot]=y;
 44     next[tot]=first[x];
 45     first[x]=tot;
 46     pass[tot]=1;
 47 }
 48 void add(int x,int y){
 49     insert(x,y);op[tot]=tot+1;insert(y,x);op[tot]=tot-1;
 50 }
 51 void Insert(int x,int y){
 52     Tot++;
 53     Go[Tot]=y;
 54     Next[Tot]=First[x];
 55     First[x]=Tot;
 56 }
 57 void Add(int x,int y){
 58     Insert(x,y);Insert(y,x);
 59 }
 60 int bfs(int x){
 61     int h=1,t=1;
 62     bool ck=0;
 63     c[1]=x;vis[x]=1;if (b[x]) ck=1;
 64     while (h<=t){
 65         int now=c[h++];
 66         for (int i=First[now];i;i=Next[i]){
 67             int pur=Go[i];
 68             if (vis[pur]) continue;
 69             c[++t]=pur;
 70             vis[pur]=1;
 71             if (b[pur]) ck=1;
 72         }
 73     }
 74     if (!ck) pd=1;
 75     return t;
 76 }
 77 void dFs(int x){
 78     if (x==n){
 79         pd=0;
 80         int bl=0;
 81         for (int i=1;i<=n;i++)
 82          First[i]=0;
 83         Tot=0; 
 84         for (int i=1;i<n;i++)
 85          if (!e[i].id) Add(e[i].u,e[i].v);
 86         for (int i=1;i<=n;i++)
 87           vis[i]=0;
 88         for (int i=1;i<=n;i++)
 89          if (!vis[i])
 90           bl=std::max(bl,bfs(i));
 91         if (pd==0) ans=std::min(ans,bl);     
 92         return;
 93     }
 94     e[x].id=1;
 95     dFs(x+1);
 96     e[x].id=0;
 97     dFs(x+1);
 98 }
 99 void sxpianfen(){
100     for (int i=1;i<n;i++) e[i].id=0;
101     dFs(1);
102 }
103 void clear(int x){
104     int h=1,t=1;
105     C[1]=x;
106     bool ppp=1;
107     if (b[x]) Cnt++,ppp=0;
108     vis[x]=1;b[x]=0;
109     while (h<=t){
110         int now=C[h++];
111         for (int i=first[now];i;i=next[i]){
112             int pur=go[i];
113             if (pass[i]) continue;
114             if (vis[pur]) continue;
115             C[++t]=pur;
116             vis[pur]=1;
117             if (b[pur]) Cnt++,ppp=0;
118             b[pur]=0;
119         }
120     }
121     if (ppp) {
122         pd=1;
123         return;
124     }
125     if (t>block) pd=1;
126     sum-=t;
127 }
128 void work(int x,int mid,int fa,int Edge){
129     if (c[x]==1&&b[fa]==1&&son[x]<=block) {
130         pass[Edge]=1;
131         pass[op[Edge]]=1;
132         clear(x);
133         id1=x;id2=fa;
134         if (pd) return;
135         return;
136     }
137     else
138     if (k-Cnt-c[x]==1&&b[x]==1&&sum-son[x]<=block){
139         pass[Edge]=1;
140         pass[op[Edge]]=1;
141         clear(fa);
142         id1=x;id2=fa;
143         if (pd) return;
144         return;
145     }
146     else
147     if (c[x]==1&&son[x]<=block&&son[fa]>=block){
148         pass[Edge]=1;
149         pass[op[Edge]]=1;
150         clear(x);
151         id1=x;id2=fa;
152         if (pd) return;
153         return;
154     }else
155     if (k-Cnt-c[x]==1&&sum-son[x]==block){
156         pass[Edge]=1;
157         pass[op[Edge]]=1;
158         clear(fa);
159         id1=x;id2=fa;
160         if (pd) return;
161         return;
162     }
163     for (int i=first[x];i;i=next[i]){
164         int pur=go[i];
165         if (pur==fa) continue;
166         if (vis[pur]) continue;
167         if (pass[i]) continue;
168         work(pur,mid,x,i);
169     }
170 }
171 bool check(int mid){
172     for (int i=1;i<n;i++) std::swap(e[rand()%(n-1)+1],e[rand()%(n-1)+1]);
173     for (int i=1;i<=n;i++) first[i]=0;
174     tot=0;
175     for (int i=1;i<n;i++)
176      add(e[i].u,e[i].v);
177     block=mid;pd=0;
178     for (int i=1;i<=tot;i++)
179      pass[i]=0;
180     for (int i=1;i<=n;i++)
181      b[i]=B[i],vis[i]=0;
182     id1=1;id2=0;vis[0]=1;
183     sum=n;Cnt=0;
184     for (int i=1;i<=k;i++){
185       if (vis[id1]&&vis[id2]) break;
186       if (k-Cnt==1) break;
187       if (!vis[id1]){
188        Dfs(id1,0);
189        work(id1,mid,0,0);
190       }else{
191        Dfs(id2,0);
192        work(id2,mid,0,0);    
193       }
194       if (pd) return 0;
195     }  
196     for (int i=1;i<=n;i++)
197      if (!vis[i]) clear(i);
198     if (pd) return 0; 
199     return 1; 
200 }
201 void solve(){
202     int l=n/k,r=n,Ans=n;
203     while (l<=r){
204         int mid=(l+r)/2;
205         if (check(mid)) r=mid-1,Ans=mid;
206         else l=mid+1;
207     }
208     printf("%d\n",Ans);
209 }
210 void solve2(){
211     int l=n/k,r=n,Ans=n;
212     while (l<=r){
213         int mid=(l+r)/2;
214         if (check(mid)) r=mid-1,Ans=mid;
215         else l=mid+1;
216     }
217     int Tn=Ans;
218     l=n/k,r=n,Ans=n;
219     while (l<=r){
220         int mid=(l+r)/2;
221         if (check(mid)) r=mid-1,Ans=mid;
222         else l=mid+1;
223     }
224     Tn=std::min(Tn,Ans);
225     printf("%d\n",Tn);
226 }
227 int main(){
228     //
229     freopen("deep.in","r",stdin);
230     freopen("deep.out","w",stdout);
231     srand(time(NULL));
232     ans=inf;
233     n=read();k=read();
234     for (int i=1;i<n;i++){
235         int x=read(),y=read();
236         add(x,y);
237         e[i].u=x;e[i].v=y;
238     }
239     for (int i=1;i<=k;i++){
240         int x=read();
241         b[x]=1;B[x]=1;
242     }
243     if (n<=20) {sxpianfen();printf("%d\n",ans);return 0;}
244     if (k==1) {printf("%d\n",n);return 0;}
245     if (k==2) {sbpianfen();return 0;}
246     if (n<=2000) {solve();return 0;}
247     if (k==3) {solve2();return 0;}
248     if (k==n) {printf("%d\n",1);return 0;}
249     if (k==n-1) {printf("%d\n",2);return 0;}
250     solve();
251 }

AC程序不知道短到哪里去了

 1 #include<algorithm>
 2 #include<cstdio>
 3 #include<cmath>
 4 #include<cstring>
 5 #include<iostream>
 6 #define N 200005
 7 int tot,go[N*2],next[N*2],first[N];
 8 int n,k,b[N],fa[N],mx[N],sum[N],vis[N],c[N];
 9 int read(){
10     char ch=getchar();int t=0,f=1;
11     while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
12     while ('0'<=ch&&ch<='9'){t=t*10+ch-'0';ch=getchar();}
13     return t*f;
14 }
15 void insert(int x,int y){
16     tot++;
17     go[tot]=y;
18     next[tot]=first[x];
19     first[x]=tot;
20 }
21 void add(int x,int y){
22     insert(x,y);insert(y,x);
23 }
24 void bfs(){
25     int h=1,t=1;for (int i=1;i<=n;i++) vis[i]=0;
26     c[1]=1;
27     vis[1]=1;
28     while (h<=t){
29         int now=c[h++];
30         for (int i=first[now];i;i=next[i]){
31             int pur=go[i];
32             if (vis[pur]) continue;
33             vis[pur]=1;
34             c[++t]=pur;
35             fa[pur]=now;
36         }
37     }
38 }
39 bool check(int mid){
40     int f;
41     memset(sum,0,sizeof sum);
42     memset(mx,0,sizeof mx);
43     for (int i=n;i>=1;i--){
44         int u=c[i];
45         if (b[u]) mx[u]=mid-1;
46         else sum[u]++;
47         f=(mx[u]>=sum[u])?mx[u]-sum[u]:-sum[u];
48         if (u==1&&f<0) return 0;
49         if (f<0) sum[fa[u]]-=f;
50         else mx[fa[u]]=std::max(mx[fa[u]],f);
51     }
52     return 1;
53 }
54 int main(){
55     n=read();k=read();
56     for (int i=1;i<n;i++){
57         int x=read(),y=read();
58         add(x,y);
59     }
60     for (int i=1;i<=k;i++){
61         int x=read();
62         b[x]=1;
63     }
64     bfs();
65     int l=n/k,r=n,ans;
66     while (l<=r){
67         int mid=(l+r)>>1;
68         if (check(mid)) r=mid-1,ans=mid;
69         else l=mid+1;
70     }
71     printf("%d\n",ans);
72 }

 

转载于:https://www.cnblogs.com/qzqzgfy/p/5590993.html

1、资源项目源码均已通过严格试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。
应用背景为变电站电力巡检,基于YOLO v4算法模型对常见电力巡检目标进行检,并充分利用Ascend310提供的DVPP等硬件支持能力来完成流媒体的传输、处理等任务,并对系统性能做出一定的优化。.zip深度学习是机器学习的一个子领域,它基于人工神经网络的研究,特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征,这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分: 1. **神经网络(Neural Networks)**:深度学习的基础是人工神经网络,它是由多个层组成的网络结构,包括输入层、隐藏层和输出层。每个层由多个神经元组成,神经元之间通过权重连接。 2. **前馈神经网络(Feedforward Neural Networks)**:这是最常见的神经网络类型,信息从输入层流向隐藏层,最终到达输出层。 3. **卷积神经网络(Convolutional Neural Networks, CNNs)**:这种网络特别适合处理具有网格结构的数据,如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络(Recurrent Neural Networks, RNNs)**:这种网络能够处理序列数据,如时间序列或自然语言,因为它们具有记忆功能,能够捕捉数据中的时间依赖性。 5. **长短期记忆网络(Long Short-Term Memory, LSTM)**:LSTM 是一种特殊的 RNN,它能够学习长期依赖关系,非常适合复杂的序列预任务。 6. **生成对抗网络(Generative Adversarial Networks, GANs)**:由两个网络组成,一个生成器和一个判别器,它们相互竞争,生成器生成数据,判别器评估数据的真实性。 7. **深度学习框架**:如 TensorFlow、Keras、PyTorch 等,这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数(Activation Functions)**:如 ReLU、Sigmoid、Tanh 等,它们在神经网络中用于添加非线性,使得网络能够学习复杂的函数。 9. **损失函数(Loss Functions)**:用于评估模型的预与真实值之间的差异,常见的损失函数包括均方误差(MSE)、交叉熵(Cross-Entropy)等。 10. **优化算法(Optimization Algorithms)**:如梯度下降(Gradient Descent)、随机梯度下降(SGD)、Adam 等,用于更新网络权重,以最小化损失函数。 11. **正则化(Regularization)**:技术如 Dropout、L1/L2 正则化等,用于防止模型过拟合。 12. **迁移学习(Transfer Learning)**:利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就,但它也面临着一些挑战,如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
深度学习是机器学习的一个子领域,它基于人工神经网络的研究,特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征,这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分: 1. **神经网络(Neural Networks)**:深度学习的基础是人工神经网络,它是由多个层组成的网络结构,包括输入层、隐藏层和输出层。每个层由多个神经元组成,神经元之间通过权重连接。 2. **前馈神经网络(Feedforward Neural Networks)**:这是最常见的神经网络类型,信息从输入层流向隐藏层,最终到达输出层。 3. **卷积神经网络(Convolutional Neural Networks, CNNs)**:这种网络特别适合处理具有网格结构的数据,如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络(Recurrent Neural Networks, RNNs)**:这种网络能够处理序列数据,如时间序列或自然语言,因为它们具有记忆功能,能够捕捉数据中的时间依赖性。 5. **长短期记忆网络(Long Short-Term Memory, LSTM)**:LSTM 是一种特殊的 RNN,它能够学习长期依赖关系,非常适合复杂的序列预任务。 6. **生成对抗网络(Generative Adversarial Networks, GANs)**:由两个网络组成,一个生成器和一个判别器,它们相互竞争,生成器生成数据,判别器评估数据的真实性。 7. **深度学习框架**:如 TensorFlow、Keras、PyTorch 等,这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数(Activation Functions)**:如 ReLU、Sigmoid、Tanh 等,它们在神经网络中用于添加非线性,使得网络能够学习复杂的函数。 9. **损失函数(Loss Functions)**:用于评估模型的预与真实值之间的差异,常见的损失函数包括均方误差(MSE)、交叉熵(Cross-Entropy)等。 10. **优化算法(Optimization Algorithms)**:如梯度下降(Gradient Descent)、随机梯度下降(SGD)、Adam 等,用于更新网络权重,以最小化损失函数。 11. **正则化(Regularization)**:技术如 Dropout、L1/L2 正则化等,用于防止模型过拟合。 12. **迁移学习(Transfer Learning)**:利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就,但它也面临着一些挑战,如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
深度学习是机器学习的一个子领域,它基于人工神经网络的研究,特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征,这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分: 1. **神经网络(Neural Networks)**:深度学习的基础是人工神经网络,它是由多个层组成的网络结构,包括输入层、隐藏层和输出层。每个层由多个神经元组成,神经元之间通过权重连接。 2. **前馈神经网络(Feedforward Neural Networks)**:这是最常见的神经网络类型,信息从输入层流向隐藏层,最终到达输出层。 3. **卷积神经网络(Convolutional Neural Networks, CNNs)**:这种网络特别适合处理具有网格结构的数据,如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络(Recurrent Neural Networks, RNNs)**:这种网络能够处理序列数据,如时间序列或自然语言,因为它们具有记忆功能,能够捕捉数据中的时间依赖性。 5. **长短期记忆网络(Long Short-Term Memory, LSTM)**:LSTM 是一种特殊的 RNN,它能够学习长期依赖关系,非常适合复杂的序列预任务。 6. **生成对抗网络(Generative Adversarial Networks, GANs)**:由两个网络组成,一个生成器和一个判别器,它们相互竞争,生成器生成数据,判别器评估数据的真实性。 7. **深度学习框架**:如 TensorFlow、Keras、PyTorch 等,这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数(Activation Functions)**:如 ReLU、Sigmoid、Tanh 等,它们在神经网络中用于添加非线性,使得网络能够学习复杂的函数。 9. **损失函数(Loss Functions)**:用于评估模型的预与真实值之间的差异,常见的损失函数包括均方误差(MSE)、交叉熵(Cross-Entropy)等。 10. **优化算法(Optimization Algorithms)**:如梯度下降(Gradient Descent)、随机梯度下降(SGD)、Adam 等,用于更新网络权重,以最小化损失函数。 11. **正则化(Regularization)**:技术如 Dropout、L1/L2 正则化等,用于防止模型过拟合。 12. **迁移学习(Transfer Learning)**:利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就,但它也面临着一些挑战,如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值