cf训练赛20190806

A. Nested Segments

题目链接
题意：有n个区间，问对于每个区间，他包含多少个区间。
思路：将每个区间按左端点从小到大排序，并将右端点离散化，用树状数组来记录每一个右端点。按左端点从小到大遍历，直接输出getsum(右端点)，并将此右端点删除即可。

#include<bits/stdc++.h>
#define LL long long
#define INF 0x3f3f3f3f

using namespace std;
const int maxn=2e5+5;

struct node
{
    int l,r,id;
}a[maxn];
int n,sum[maxn];

int lowbit(int x)
{
    return x&(-x);
}

void updata(int x,int d)
{
    while(x<maxn)
    {
        sum[x]+=d;
        x+=lowbit(x);
    }
}

int getsum(int x)
{
    int res=0;
    while(x>0)
    {
        res+=sum[x];
        x-=lowbit(x);
    }
    return res;
}

bool cmp(node aa,node bb)
{
    if(aa.l==bb.l)return aa.r>bb.r;
    return aa.l<bb.l;
}
int ans[maxn];
int main()
{
    scanf("%d",&n);
    vector<int>v;
    memset(sum,0,sizeof(sum));
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&a[i].l,&a[i].r);
        a[i].id=i;
        v.push_back(a[i].r);
    }
    sort(v.begin(),v.end());
    int k=unique(v.begin(),v.end())-v.begin();///右端点离散化
    for(int i=1;i<=n;i++)
    {
        a[i].r=(lower_bound(v.begin(),v.begin()+k,a[i].r)-v.begin()+1);
    }
    sort(a+1,a+1+n,cmp);
    for(int i=1;i<=n;i++)///先将每个右端点都记录一下
    {
        updata(a[i].r,1);
    }
    for(int i=1;i<=n;i++)
    {
        ans[a[i].id]=getsum(a[i].r)-1;
        updata(a[i].r,-1);
    }
    for(int i=1;i<=n;i++)
    {
        printf("%d\n",ans[i]);
    }
}

B. Felicity is Coming!

题目链接
题意：有n个集合，每个集合有一定数量的精灵，精灵的品种共有m个，精灵可以进化为任意物种（包括自己），问共有多少种进化方案满足每个集合进化前后，给个物种的数量相等。（题意还是比较难懂。。。）
思路：对于两个物种，如果他们所在的集合完全一样，那么他们就可以相互转化。假设有n个品种所在的集合完全一样，那么这种集合组合所能产生的方案数就为n！。
这道题让我学到了二维vector的sort()方法，用vector存储每个物种的所在的集合，将vector排序之后，所在集合完全相同的物种只会出现在相邻两个。

#include<bits/stdc++.h>
#define LL long long
#define INF 0x3f3f3f3f

using namespace std;
const int maxn=1e6+5;
const int mod=1e9+7;

int n,m;
vector<int>v[maxn];

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
         int k;
         scanf("%d",&k);
         for(int j=1;j<=k;j++)
         {
             int x;
             scanf("%d",&x);
             v[x].push_back(i);
         }
    }
    sort(v+1,v+1+m);///这样排序，是按每一行的字典序进行排序
    LL cnt=1,ans=1;
    for(int i=2;i<=m;i++)
    {
        if(v[i]==v[i-1])
        {
            cnt++;
            ans=(ans*cnt)%mod;
        }
        else cnt=1;
    }
    cout<<ans<<endl;
}

C. Igor In the Museum

题意：n*m的矩阵, " * "，代表墙， “ .＂代表空地，相邻空地和墙之间有一幅画，给定ｋ个起始点，问对于每个起始点能看到最多多少幅画。
思路：题目给的数据较大，如果ｋ次ｂｆｓ显然会超时，所以我们对于一个连同的区域只进行一次ｄｆ·ｓ，并将这个区域的只都记录下来，如果再访问到这个区域，就直接输出答案。

#include<bits/stdc++.h>
#define LL long long
#define INF 0x3f3f3f3f
 
using namespace std;
const int maxn=1005;
 
int n,m,k;
char mp[1005][1005];
LL ans;
int dx[4]= {1,-1,0,0};
int dy[4]= {0,0,1,-1};
int vis[maxn][maxn];
int a[maxn];
int cnt;
struct node
{
    int x,y;
};
 
void bfs(int x,int y)
{
    ans=0;
    queue<node>q;
    while(!q.empty())
    {
        q.pop();
    }
    q.push(node{x,y});
    vis[x][y]=cnt;///将此区域的所有点都标记为一个集合
    while(!q.empty())
    {
        node temp=q.front();
        q.pop();
        for(int i=0; i<4; i++)
        {
            int xx=dx[i]+temp.x;
            int yy=dy[i]+temp.y;
            if(vis[xx][yy]||xx<1||yy<1||xx>n||yy>m)continue;
            if(mp[xx][yy]=='*')
            {
                ans++;
                continue;
            }
            vis[xx][yy]=cnt;
            q.push({xx,yy});
        }
    }
    a[vis[x][y]]=ans;///记录此区域的答案
}
 
 
int main()
{
    cnt=1;
    memset(a,0,sizeof(a));
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1; i<=n; i++)
    {
        scanf("%s",mp[i]+1);
    }
    memset(vis,0,sizeof(vis));
    while(k--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(a[vis[x][y]])///如果此区域已经被bfs过，就直接输出
        {
            printf("%d\n",a[vis[x][y]]);
        }
        else
        {
            bfs(x,y);
            printf("%d\n",ans);
            cnt++;
        }
 
    }
}

D. King’s Path

题目链接
题意：一个棋盘中，有一些能走的点，皇后最开始在一个点，皇后可以向任意相邻的格子走，问皇后走到固定一点的最少步数，如果不能到达，输出-1.
思路：bfs。但是题目给的坐标范围很大，需要用pair存图。

#include<bits/stdc++.h>
#define LL long long
#define INF 0x3f3f3f3f

using namespace std;
struct node
{
    int x,y,step;
};
int n;
map< pair<int,int>,int>mp;
map<pair<int,int>,int>vis;
int dx[8]={1,-1,1,-1,0,0,-1,1};
int dy[8]={0,0,1,1,1,-1,-1,-1};

int bfs(int x0,int y0,int x1,int y1)
{
    queue<node>q;
    while(!q.empty())q.pop();
    q.push(node{x0,y0,0});
    vis[make_pair(x0,y0)]=1;
    while(!q.empty())
    {
        node p;
        p=q.front();
        q.pop();
        if(p.x==x1&&p.y==y1)
        {
            return p.step;
        }
        for(int i=0;i<8;i++)
        {
            int xx=p.x+dx[i];
            int yy=p.y+dy[i];
            if(vis[make_pair(xx,yy)]==1||(mp[make_pair(xx,yy)]!=1))continue;
            vis[make_pair(xx,yy)]=1;
            q.push(node{xx,yy,p.step+1});
        }
    }
    return -1;
}

int main()
{
    mp.clear();
    vis.clear();
    int x0,y0,x1,y1;
    scanf("%d%d%d%d",&x0,&y0,&x1,&y1);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int a,b,r;
        scanf("%d%d%d",&r,&a,&b);
        for(int j=a;j<=b;j++)
        {
            mp[make_pair(r,j)]=1;///将能走的点标记为1
        }
    }
    printf("%d\n",bfs(x0,y0,x1,y1));
}

E. Extract Numbers

模拟水题。。。略过。。。（但是当时不细心还是卡了很长时间。。。）

F. Vanya and Label

题目链接
题意：一个字符串，每个字符都有相应的大小，问有多少个与它长度相等的字符串，和他按位与之后与原字符串相等。
思路： 转化为二进制后如果某一位是1，那么要想&之后不变，对应的一位也应是1,。如果某一位是0，那么对应的一位有三种情况，0&0=0,0&1=0,1&0=0，所以只要统计每一个字符有多少位是0，假设有n位是0，最后的结果就是3的n次方。

#include<bits/stdc++.h>
#define LL long long
#define INF 0x3f3f3f3f
 
using namespace std;
const int mod=1e9+7;
 
int check(char s)
{
    if(s>='0'&&s<='9')
    {
        return s-'0';
    }
    else if(s>='a'&&s<='z')
    {
        return s-'a'+36;
    }
    else if(s>='A'&&s<='Z')
    {
        return s-'A'+10;
    }
    else if(s=='-')return 62;
    else if(s=='_')return 63;
}
int main()
{
    string s;
    cin>>s;
    int len=s.length();
    LL ans=1;
    for(int i=0;i<len;i++)
    {
        int temp=check(s[i]);
        for(int j=0;j<=5;j++)
        {
            if(!((temp>>j)&1))///快速幂
            {
                ans=ans*3%mod;
            }
        }
    }
    cout<<ans<<endl;
}