icpc泉城联赛第三次训练赛

1.线段树仍在学习中

2.比赛的时候这个题没归我管，现进行赛后补题；

题目大意：给定一个长度为n的字符串，要求打印第k字典序最小的字符出（k<n)

并且给出了字符串a字典序小于字符串b的定义：

（1）存在一个i使得a[i]<b[i]且满足a[j]=b[j]（j<i)

（2）a字符串是b字符串的子集

题目要给出n个字符串来找第k小的字符串（在主串中找匹配串），并且注意到题目说输入的时候先输入的字母是比后输入的字母小，是递减的趋势；

例如，第一行中的acb···xyz表示字符“c”小于字符“b”，而字符“c”大于字符“a”；

单靠ascll字符是不行的，需要用一个数组来记录他们的大小，除此之外，要找满足条件的字符串需要以主串为准来对子串进行一个有规则的排序；

这个规则就是上面说的字典序小的规则；

然后输出就可以了，并且这道题目存在使用string,千万小心，

 

 由于个人电脑原因vjuidge打不开，所以只有题目测试样例过了的代码，正确性仍需检验：

#include<bits/stdc++.h>
using namespace std;
int n,k;
string s;
int num[1010];//储存字母大小
string ch[1010];//n个子串
bool cmp(string a,string b)//字典序规则
{
    int len1=a.length();
    int len2=b.length();
    for(register int i=0,j=0;i<len1&&j<len2;i++,j++)
    {
        if(num[a[i]]<num[b[j]])
        return true;
        else if(num[a[i]]>num[b[j]])
        return false;
    }
     if(len1<len2)
    return true;
    else
    return false;
}
int main()
{
    /*std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0)*/;
    getline(cin,s);
    for(register int i=0;i<26;i++)
    {
        num[s[i]]=i;//储存
    }
    cin>>n;
    cin.get();//注意空格
    for(register int i=0;i<n;i++)
    {
        getline(cin,ch[i]);
    }
    cin>>k;
    sort(ch,ch+n,cmp);
    cout<<ch[k-1]<<endl;//第k小
}
/*acbdefghijklmnopqrstuvwxyz
2
abc
acb
1
*/

c依旧是不会，dfs这玩意用两个vis数组不行吗？

放上失败代码，以后有空研究这个题；

#include<bits/stdc++.h>
using namespace std;
char ch[100][100];
int n;
int mint=0x3f3f3f3f;
const int INF=0x3f3f3f3f;
bool check(int x, int y){
     if(x < 0 || y < 0 || x >= n || y >= n) 
     return false;
     return true;
 }
int dir[5][2]=
{
    {-1,0},
    {0,-1},
    {1,0},
    {0,1},
};
bool vis1[100][100];
bool vis2[100][100];
void dfs(int sx,int sy,int tx,int ty,int step)
{
    vis1[sx][sy]=true;
    vis2[tx][ty]=true;
    if(sx==tx&&sy==ty)
    {
        mint=min(mint,step);
        return ;
    }
    for(register int i=0;i<4;i++)
    {
        int newax=sx+dir[i][0];
        int neway=sy+dir[i][1];
        int newbx=tx+dir[i][0];
        int newby=ty+dir[i][1];
        if(check(newax,neway)&&check(newbx,newby)&&ch[newax][neway]=='.'&&ch[newbx][newby]=='.')
        {
            if(!vis1[newax][neway]&&!vis2[newbx][newby])
            {
                 dfs(newax,neway,newbx,newby,step+1);
            }
        }
        else if(check(newax,neway)&&ch[newax][neway]=='.')
        {
            if(!vis1[newax][neway])
            {
                 dfs(newax,neway,tx,ty,step+1);
            }
        }
            else if(check(newbx,newby)&&ch[newbx][newby]=='.')
            {
                if(!vis2[newbx][newby])
                {
                    dfs(sx,sy,newbx,newby,step+1);
                }
            }
            else
            continue;
    }
}
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
     int xa,ya,xb,yb;
    cin>>n;
    for(register int i=0;i<n;i++)
        {
            for(register int j=0;j<n;j++)
            {
                cin>>ch[i][j];
                if(ch[i][j]=='a')
                {
                    xa=i;
                    ya=j;
                }
                if(ch[i][j]=='b')
                {
                    xb=i;
                    yb=j;
                }
            }
        }
        dfs(xa,ya,xb,yb,0);
        if(mint<INF)
        {
            cout<<mint<<endl;
        }
        else
        {
            cout<<"no solution"<<endl;
        }
    return 0;
}

d

题目大意：给定一个数组，求a[i]%a[j]的最大值，i,j满足1<=i,j<=n&&a[i]>=a[j]

对于所有的 ai 找到 k * ai 和 (k + 1) * aj , (k = 1 2 3....) 对于 ai 能

取到最大值的肯定是 k * ai 和 (k + 1) * aj 每个区间中的最大值

mod ai 取到数然后取最大值，这是官方给的解释

那很明显我们要求的是a[i]=k*a[j]+x，ans=x;

题目说要求余数的最大值，所以我们要做一个排序的前提下还要求k

以下是试错的过程：

从大到小枚举a[j]后，枚举倍数k

首先暴力过不了，挨个枚举试过了，不行

贪心试过了，听别人说剪枝也不行；

二分可以试试，每次查找求最近与a[j]的倍数k

其实贪心是可行的，二分也是可行的，甚至官方都说筛法也是可行的

我的做法是

对数组排序之后从后往前找，如果x已经大于下一个a[j]-1则停止

对于每一个a[j]用二分找到它每个倍数对应的a[i]

那a[i-1]就是我们想要的最大的余数

这里才用反向查找的目的是为了如果后序发现了当前数值和前一个数值出现重复判断则进行剪枝测率

其实也可以用unique去重

还有一个就是正向的我已经跑过了，所以说采取反向的查找测率可以在一定程度上降低一定的时间复杂度

#include<bits/stdc++.h>
using namespace std;
const int num=3e5;
int a[num];
int n;
int s;
int ans;
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n;
    for(register int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    sort(a+1,a+1+n);//为了查找接近与a[j]的倍数k
    /*for(register int i=1;i<=n;i++)
    {
        if(a[i]==a[i-1])
        {
            continue;
        }
        else
        {
            a[i]=a[i-1]+1;
        }
        for(register int j=2*a[i];j<=a[n];j+=a[n])
        {
            //s=upper_bound(a+1,a+1+n,j)-a;
            s=lower_bound(a+1,a+1+n,j)-a;
            ans=max(ans,a[s]%a[i]);
        }
         ans=max(ans,a[n]%a[i]);
    }*/
    for(register int i=n;i>=1;i--)
    {
        if(ans>a[i]-1)//找到了立刻停止
        break;
        if(i<n)//剪枝
        {
            if(a[i]==a[i+1])
            continue;
        }
        for(register int j=2*a[i];j<=a[n];j+=a[i])//从2*a[i]开始，枚举倍数k
        {
            s=lower_bound(a+1,a+1+n,j)-a;//二分查找
            if(s==0)
            continue;
            s--;
            ans=max(ans,a[s]%a[i]);//更新区间
        }
        ans=max(ans,a[n]%a[i]);//求最大余数
    }
    cout<<ans;
    return 0;
}

efgh没归我管，暂时没空补题；

i题

学习了一种新的筛法

 

 即：

int is_prime(int n1)
{
    if(n1==2||n1==3)
    return 1;
    if(n1%6!=1&&n1%6!=5)
    return 0;
    for(register int i=5;i<=floor(sqrt(n1));i+=6)
    {
        if(n1%i==0||n1%(i+2)==0)
        return 0;
    }
    return 1;
}

这种筛素数的方法比普通版快，但是埃氏快不快就不知道了，然后就是筛和选数字了，这里有一个取巧的方法就是先筛出素数来在选数，这样远比判筛边选书要快

还是受别人之启发哈哈哈

 

失败代码：（tle绝对了）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll ans;
ll n;
bool is_prime(long long n)
{
    if(n<=1)
    return false;
    for(register ll i=2;i<=sqrt(n);i++)
    {
        if(n%i==0)
        return false;
    }
    return true;
}
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n;
    for(register ll q=2;q<=sqrt(n);q++)
    {
        for(register ll p=2;p<q;p++)
        {
            for(register ll i=2;i<=n;i++)
            if(p*pow(q,3)==i)
            {
                if(is_prime(p)&&is_prime(q))
                {
                    ans++;
                }
            }
        }
    }
    cout<<ans;
    return 0;
}

 

 AC代码：

#include<bits/stdc++.h>
using namespace std;
const int num=1e6;
typedef long long ll;
int a[num];
ll ans;
ll n;
int is_prime(int n1)//is_prime+(plus)
{
    if(n1==2||n1==3)
    return 1;
    if(n1%6!=1&&n1%6!=5)
    return 0;
    for(register int i=5;i<=floor(sqrt(n1));i+=6)
    {
        if(n1%i==0||n1%(i+2)==0)
        return 0;
    }
    return 1;
}

int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n;
    ll flag=1;
    for(register ll i=2;i<=num;i++)//先筛出来
    {
        if(is_prime(i)==1)
        {
            a[flag]=i;
            flag++;
        }
    }
    ll L=1;
    ll R=flag-1;
    if(n<8)
    cout<<"0"<<endl;
    else
    {
        
    while(L<R)//选数
    {
        if(a[L]*pow(a[R],3)>n)
        {
            R--;
        }
        else
        {
            ans+=(R-L);
            L++;
        }
    }
        cout<<ans<<endl;
}
    return 0;
}

j没归我管，以后补题

k题

题目大意：给定一张有向图（DAG），求从某点开始能无限循环的点的个数。

也就是说一个点如果可以从这里出发然后无穷尽的走下去，这种点就是我们需要的点

因为没有出边的点必定是环而且只有通

向环出边的点是环路。

所以说首先那些出度为0的点不行

所以说，所以我们考虑建立反图

因为环是不随边的正反性而发生变化，我们如果对这个图进行一次拓扑一来可以从终点到起点，省去了终点不定的问题，二来我们可以得到反图不能到的点,

而这种点的求法恰好是所有点的个数减去所有通向环的点的个数再以所有点的个数

 

 

其实一上来我采取的是正向跑图的方法，因为做的时候组内有人画出了题目大体的图，既然题目要求环路的话则拓扑排序不失为一个判环的好方法，而正向跑图却忽略了一些点我们是到达不了的

而且还在入度的细节方面出了问题

 

 错误代码：

#include<bits/stdc++.h>
using namespace std;
int n,m;
const int num=2e5+10;
vector<int>edge[num];
int in[num];
vector<int>topo;
queue<int>q;
int ans;
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m;
    for(register int i=1;i<=m;i++)
    {
        int a,b;
        cin>>a>>b;
        edge[a].push_back(b);
        in[a]++;
    }
    for(register int i=1;i<=n;i++)
        if(!in[i])
        {
                q.push(i);
        }
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        topo.push_back(x);
        ans++;
        for(register int k=0;k<edge[x].size();k++)
        {
            int b=edge[x][k];
            if(!in[b]--) 
            q.push(b);
        }
    }
    ans=n-ans;
    cout<<ans<<endl;
    return 0;
}

AC代码如下：

#include<bits/stdc++.h>//icpc泉赛twice k
using namespace std;
int n,m;
const int num=2e5+10;
vector<int>edge[num];
int in[num];
//vector<int>topo;
queue<int>q;
int ans;
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m;
    for(register int i=1;i<=m;i++)
    {
           int a,b;
        cin>>a>>b;
        edge[b].push_back(a);
        in[a]++;
    }
    for(register int i=1;i<=n;i++)
        if(!in[i])
        {
                q.push(i);
        }
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        //topo.push_back(x);
        ans++;
        for(register int k=0;k<edge[x].size();k++)
        {
            int b=edge[x][k];
            in[b]--;
            if(!in[b]) 
            q.push(b);
        }
    }
       ans=n-ans;//所有的点减去环路点即是结果
       cout<<ans<<endl;
    return 0;
}

L题没必要，还没接触到莫队

 

总结：

题目难度有一定的思维量和难度，但比起省赛还是差了点意思

 

这次做题还是发现了一些问题，就是对于一些优化方法上的空缺

最重要的是我终于把学习线段树提上了日程

然后就是基础算法的一些强化和变形仍需学习

这就需要刷大量的算法题来应对不同的算法变形

也要刷一定的思维题来保证思维的活跃