A
题意&思路:找到B连续出现的个数
#include<bits/stdc++.h>
using namespace std;
vector<int>ans;
int main(){
int n;
while(cin>>n){
string s;cin>>s;
ans.clear();
int t=0;
for(int i=0;i<n;i++){
if(s[i]=='B'){
t++;
}
else{
if(t>0) ans.push_back(t);
t=0;
}
}
if(t>0) ans.push_back(t);
if(ans.size()==0){
cout<<0<<endl;
continue;
}
cout<<ans.size()<<endl;
for(int i=0;i<ans.size()-1;i++) cout<<ans[i]<<" ";
cout<<ans[ans.size()-1]<<endl;
}
}
B
题意&思路:n个串,问你如果从长度从小到大,(也就是同一个长度可以决定谁最先最后),随机找到心仪的那个需要最少时间和最多时间,每一次查找需要1秒,每隔k个串需要额外5秒。
#include<bits/stdc++.h>
using namespace std;
string s[110],str;
int main(){
int n,k;
while(cin>>n>>k){
for(int i=0;i<n;i++) cin>>s[i];
cin>>str;
int t1=0,t2=0;
for(int i=0;i<n;i++){
if(s[i].size()<str.size()) t1++;
if(s[i].size()<=str.size()) t2++;
}
t1+=1;
t1=(t1-1)/k*5+t1;t2=(t2-1)/k*5+t2;
cout<<t1<<" "<<t2<<endl;
}
}
C. Journey(补)
题意:
在一个DAG图上(有向无环),每条边都有一个时间t[i]的权值,给你总时间T,问从1点出发到n
点总时间小于T并且经过点的个数最多的路线。
思路:典型的DAG图上的动态规划.亏我暴力一小时。。。。
可以从两种不同角度定义dp数组,从而状态转移。
dp[i][j]
1: 表示从i点出发到n点已经经过j个点的最少时间。
那么这种转移初始化dp[n][0]=0,每个状态的子状态就是他的儿子到n点少经过一个点花费的时间,那么转移方向就是从n点到1点的方向进行。
我用邻接表存下这个DAG图,一遍记忆化dfs(1),
状态转移方程:dp[i][j]=min(dp[k][j-1]+edge(i,k)) (k是i点子节点)
时间复杂度O(n)。
#include<bits/stdc++.h>
using namespace std;
const int maxn=5000+5;
template<int N,int M>
struct Graph
{
int top;
struct Vertex{
int head;
}V[N];
struct Edge{
int v,next,t;
}E[M];
void init(){
memset(V,-1,sizeof(V));
top = 0;
}
void add_edge(int u,int v,int t){
E[top].v = v;
E[top].t=t;
E[top].next = V[u].head;
V[u].head = top++;
}
};
Graph<maxn,maxn> g;
int n,m,T,dp[maxn][maxn],pre[maxn][maxn],vis[maxn];
void dfs(int cur){
if(vis[cur]!=0) return; vis[cur]=1;
if(cur==n) dp[cur][1]=0;
for(int i=g.V[cur].head;i!=-1;i=g.E[i].next){
int s=g.E[i].v;dfs(s);
for(int j=1;j<=n;j++){
if(dp[s][j-1]+g.E[i].t<dp[cur][j]){
dp[cur][j]=dp[s][j-1]+g.E[i].t;
pre[cur][j]=s;
}
}
}
}
void print(int t,int x){
printf("%d ",x);
if(t>1) print(t-1,pre[x][t]);
}
int main(){
while(~scanf("%d%d%d",&n,&m,&T)){
g.init();
memset(vis,0,sizeof(vis));
memset(dp,0x3f,sizeof(dp));
for(int i=0;i<m;i++){
int a,b;
int c;scanf("%d%d%d",&a,&b,&c);
g.add_edge(a,b,c);
}
dfs(1);
int ans=0;
for(int i=n;i>=0;i--){
if(dp[1][i]<=T){
ans=i;break;
}
}
printf("%d\n",ans);
print(ans,1);
printf("\n");
}
}
2:
表示从1点出发到i点经过了j个点的最少时间。
那么相当于上面,这里初始化dp[1][0]=0;
,每个状态的子状态就是1到它父亲少经过一个点花费的时间,那么转移方向就是从1点到n点的方向进行。那么邻接表存图就得反向,从n到1。
状态转移方程:**dp[i][j]=min(dp[k][j-1]+edge(i,k)) (k是i点父节点)
时间复杂度O(n)。
#include<bits/stdc++.h>
using namespace std;
const int maxn=5000+5;
template<int N,int M>
struct Graph
{
int top;
struct Vertex{
int head;
}V[N];
struct Edge{
int v,next,t;
}E[M];
void init(){
memset(V,-1,sizeof(V));
top = 0;
}
void add_edge(int u,int v,int t){
E[top].v = v;
E[top].t=t;
E[top].next = V[u].head;
V[u].head = top++;
}
};
Graph<maxn,maxn> g;
int n,m,T,dp[maxn][maxn],pre[maxn][maxn],vis[maxn];
void dfs(int cur){
if(vis[cur]!=0) return; vis[cur]=1;
if(cur==1) dp[cur][1]=0;
for(int i=g.V[cur].head;i!=-1;i=g.E[i].next){
int f=g.E[i].v;dfs(f);
for(int j=1;j<=n;j++){
if(dp[f][j-1]+g.E[i].t<dp[cur][j]){
dp[cur][j]=dp[f][j-1]+g.E[i].t;
pre[cur][j]=f;
}
}
}
}
void print(int t,int x){
if(t>1) print(t-1,pre[x][t]); printf("%d ",x);
}
int main(){
while(~scanf("%d%d%d",&n,&m,&T)){
g.init();
memset(vis,0,sizeof(vis));
memset(dp,0x3f,sizeof(dp));
for(int i=0;i<m;i++){
int a,b;
int c;scanf("%d%d%d",&a,&b,&c);
g.add_edge(b,a,c);
}
dfs(n);
int ans=0;
for(int i=n;i>=0;i--){
if(dp[n][i]<=T){
ans=i;break;
}
}
printf("%d\n",ans);
print(ans,n);
printf("\n");
}
}
这两种做法本质都一样,定义好状态,就在DAG图上转移!
D. Maxim and Array
题意:给你n个数,k次操作,每次只能对一个数+x或-x,问最后使它们乘积最小的情况是。
思路:一顿贪心+优先队列logn的优化。(个人感觉比C简单,应该换一下)
如果n个数里,负数的个数是奇数个,就让排序后绝对值最小的数绝对值的增加x.
反之负数的个数是偶数,就让绝对值最小的数绝对值的减小x。每次操作后,序列绝对值最小的数会变化,用优先队列维护。
时间复杂度O(n+k*(logn));
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node{
ll v; int p;
friend bool operator <(node a,node b){
return abs(a.v)>abs(b.v);
}
};
priority_queue<node>q;
ll a[200000+10];
int main(){
int n,k,x;
while(~scanf("%d %d %d",&n,&k,&x)){
while(!q.empty()) q.pop();
int num=0,ok=0;
for(int i=0;i<n;i++){
scanf("%lld",&a[i]);q.push(node{a[i],i});
if(a[i]<0) num++;
}
while(k--){
if(num%2==0){
node t=q.top(); q.pop();
int s=t.v,e;
if(t.v>=0){
a[t.p]-=x; t.v-=x;
e=t.v;
}
else{
a[t.p]+=x; t.v+=x;
e=t.v;
}
q.push(t);
if(s>=0&&e<0) num++;
if(s<0&&e>=0) num--;
}
else{
node t=q.top();q.pop();
if(t.v>=0){
a[t.p]+=x; t.v+=x;
}
else{
a[t.p]-=x; t.v-=x;
}
q.push(t);
}
}
for(int i=0;i<n-1;i++) printf("%lld ",a[i]);
printf("%lld\n",a[n-1]);
}
}