回顾2019牛客暑期多校训练营 三四场 容器模拟，线段树，前缀和思想

第三场 J题
模拟LRU内存管理法

思路是构建一个结构体 存储相关信息。
双向链表模拟内存，再构建一个unorder_map记录对应的链表的迭代器，这样就可以移动链表中的元素时，不会等丢他的位置。注意，用map还有用cout或者cin会TLE。

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+4;
const double eps = 1e-8;
const double pi=acos(-1.0);
char catchmessage[100];
struct node{
    string str;
    int data;
    node(string _str,int _data):str(_str),data(_data)
    {

    }

    node(){}

};
list<node> li;
int q,m;
unordered_map<string,list<node>::iterator> mp;
int add(node & tmp)//here
{
    if(mp.count(tmp.str)==0)
    {
        li.push_back(tmp);
        list<node>::iterator it=li.end();
        it--;
        mp[tmp.str]=it;
        if(li.size()>m)
        {
            it=li.begin();
            unordered_map<string,list<node>::iterator>::iterator it_mp;
            it_mp=(mp.find(it->str));
            li.erase(it);
            mp.erase(it_mp);
        }
        return tmp.data;
    }
    else
    {
        tmp.data=(*mp[tmp.str]).data;
        list<node>::iterator it = mp[tmp.str];
        li.erase(it);
        li.push_back(tmp);
        it=li.end();
        it--;
        mp[tmp.str]=it;
        return tmp.data;
    }
}
void question(string & s,int & v)
{
    if(mp.count(s)==0)
    {
        printf("Invalid\n");
        return;
    }
    list<node>::iterator it=mp[s];
    if(v==0)
    {
        printf("%d\n",it->data);
        return;
    }
    if(v==1)
    {
        it++;
        if(it==li.end())
        {
            printf("Invalid\n");
            return;
        }
        else
        {
            printf("%d\n",it->data);
            return;
        }
    }
    if(v==-1)
    {

        if(it==li.begin())
        {
            printf("Invalid\n");
            return;
        }
        else
        {
            it--;
            printf("%d\n",it->data);
            return;
        }
    }
    return;
}
int main()
{
    ios::sync_with_stdio(false);
    int t;
    cin>>t;int opt;string s;int v;
    while(t--)
    {
        mp.clear();
        li.clear();
        cin>>q>>m;
        for(int j=0;j<q;j++)
        {
            cin>>opt>>s>>v;
            if(opt==0)
            {
                node tmp(s,v);
                printf("%d\n",add(tmp));
            }
            else
            {
//                for(auto j:li)
//                    cout<<j.str<<endl;
                question(s,v);
            }
        }
    }
}

第四场K题 number
八成就是临时加的签到题：
问一个串数列，其字串中能被300整除的有多少个

解：前缀和思想，先找‘00’连续两个0的位置，如果它们前面的数串可被3整除，即前面的数串和这两个0就可被300 整除。
找前面符合要求的字串通过前缀和，已知一个数若每一位数加起来能被3整除那么这个数就是3的倍数，所以我们维护前缀和对3的余数，假如我要判断第j位前有多少个数串可被3整除，只需要看前面和其与3整除余数相同的前缀和的个数即可。

#include<bits/stdc++.h>
#define LL long long
#define ms0(x) memset(x,0,sizeof(x))
#define ms-1(x) memset(x,-1,sizeof(x))
using namespace std;
vector<int> pos[3];//其实没必要用vector，但是懒，用他的size方法统计个数屡试不爽
const int maxn=1e5+5;
int f[maxn];

int qian[maxn];
int main()
{
 	ios::sync_with_stdio(false);
	string str;
	cin>>str;int cnt0=0;
	pos[0].push_back(0);
	for(int j=0;j<str.size();j++)
	{
		f[j+1]=f[j]+str[j]-'0';
		qian[j+1]=pos[f[j+1]%3].size();
		pos[f[j+1]%3].push_back(j+1);
		if(str[j]=='0')
			cnt0++;
	}
	long long ans=0;
	for(int j=0;j<str.size()-1;j++)
	{
		if(str[j]=='0'&&str[j+1]=='0')
		{
			ans++;
			ans+=qian[j];
		}
	}
	ans+=cnt0;
	cout<<ans;
	return 0;
}

第四场C题 线段树

先找a数列中a[j]在这个数列中的最大子区间，这个子区间满足其最小值是a[j]，这里用了跳转的思路，加入a[j]比a[j-1]小，那么其满足的区间肯定也包含了a[j-1]的相应区间，然后不断跳转，线性求出每个的区间。sum就让我想到b数列的前缀和，我已经求的最大区间，我需要在这个最大区间找包含的j这个位置的区间使得这个区间的和最大。线段树，区域查询即可。

#include<bits/stdc++.h>
#define LL long long
#define ms0(x) memset(x,0,sizeof(x))
#define ms-1(x) memset(x,-1,sizeof(x))
using namespace std;
const int maxn= 3e6+5;
long long a[maxn],b[maxn];
long long f[maxn];
struct tree_node{
	int l,r;
	long long maxnum;
	long long minnum;
	tree_node(LL _maxnum,LL _minnum):maxnum(_maxnum),minnum(_minnum)
	{
	 } 
	tree_node(){
	}
}tree[maxn<<2];
tree_node build(int i,int l,int r)
{
	tree[i].l=l;
	tree[i].r=r;
	if(l==r)
	{
		tree[i].maxnum=f[l];
		tree[i].minnum=f[l];
		return tree[i];
	}
	int mid=(l+r)/2;
	tree_node x=build(i<<1,l,mid);
	tree_node y=build(i<<1|1,mid+1,r);
	tree[i].maxnum=max(x.maxnum,y.maxnum);
	tree[i].minnum=min(x.minnum,y.minnum);
	return tree[i];
}
LL search_max(int i,int l,int r)
{
	if(tree[i].l>r||tree[i].r<l)
		return -0x3f3f3f3f;
	
	if(l<=tree[i].l&&tree[i].r<=r)
		return tree[i].maxnum;
	LL x,y;
	x=search_max(i<<1,l,r);
	y=search_max(i<<1|1,l,r);
	return max(x,y);
}
LL search_min(int i,int l,int r)
{
	if(tree[i].l>r||tree[i].r<l)
		return 0x3f3f3f3f;
	
	if(l<=tree[i].l&&tree[i].r<=r)
		return tree[i].minnum;
	LL x,y;
	x=search_min(i<<1,l,r);
	y=search_min(i<<1|1,l,r);
	return min(x,y);
}
int update(int i,int pos,int val)
{
	if(pos<tree[i].l||tree[i].r<pos)
		return tree[i].maxnum;
	if(tree[i].l==pos&&tree[i].r==pos)
		return tree[i].maxnum=val;
	int x,y;
	x=update(i<<1,pos,val);
	y=update(i<<1^1,pos,val);
	return tree[i].maxnum=max(x,y);
}
struct node{
	int l,r;
	node(int _l,int _r):l(_l),r(_r)
	{
		
	}
	node(){
	}
}domain[maxn],region[maxn]; 
int main()
{
 	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	a[0]=-0x3f3f3f3f;
	a[n+1]=-0x3f3f3f3f;
	for(int j=1;j<=n;j++)
	{
		cin>>a[j];
	}
	for(int j=1;j<=n;j++)
	{
		cin>>b[j];
		f[j]+=f[j-1]+b[j];

	}
	build(1,1,n);
	for(int j=1;j<=n;j++)
	{
		int l=j;
		while(l>=1)
		{
			if(a[l-1]>=a[j])
			{
				l=domain[l-1].l;
				continue;
			}
			else
			{
				break;
			}
		}
		domain[j].l=l;
	}
	for(int j=n;j>=1;j--)
	{
		int r=j;
		while(r<=n)
		{
			if(a[r+1]>=a[j])
			{
				r=domain[r+1].r;
				continue;
			}
			else
			{
				break;
			}
		}
		domain[j].r=r;
	}
	long long ans=-0x3f3f3f3f;
	LL temp;
	for(int j=1;j<=n;j++)
	{
		if(a[j]>0)
			temp=search_max(1,j,domain[j].r)-search_min(1,domain[j].l,j);
		else
			temp=search_min(1,j,domain[j].r)-search_max(1,domain[j].l,j);
		temp*=a[j];
		ans=max(ans,temp);
		if(temp==0)
		{
			ans=max(ans,a[j]*b[j]);
		}
	}
//	for(int j=1;j<=n<<1;j++)
//	{
//		cout<<j<<"   :    "<<tree[j].l<<" "<<tree[j].r<<" "<<tree[j].maxnum<<endl; 
//	}
	cout<<ans;
	return 0;
}