蓝桥杯每日一题（二分）

//1460 我在哪

暴力方法改了40分钟，好在ac了

思路：依次枚举所有字符（外层循环）；

第一个没有注意的点：没有加j的中间那层循环，直接用的while，这样会导致i后面可能有多个j的位置与i匹配，这样按着第一个匹配的匹配下去了，后面无法匹配上j就一直向后走。导致缺失情况

第二个：本质上还是一样的问题，while结束后，也就是某个匹配的结果看完了，要注意把开始匹配的位置还回到i。

#include<bits/stdc++.h>
using namespace std;
//1460. 我在哪？ 暴力枚举
const int N=1e2+10;
char s[N];
int n;
int main()
{
    cin>>n;
    int ii,jj,qi;
    scanf("%s",s);
    int ans=-1*N;
    for(int i=0; i<n; i++)
    {
        int res=0;
        int l=i;
        for(int j=i+1; j<n; j++)
        {
            int r=j;
            while(r<n)
            {
                if(s[r]==s[l])
                {
                  l++,r++,res++;
                }
                else
                {
                    break;
                }
            }
            l=i;
            ans=max(ans,res);
            res=0;
        }
    }
    cout<<ans+1<<endl;//找不出来哪里错了；
}

二分的本质没理解透：

不是看不到有序的东西就不能用二分去做。

可以用二分的本质是进行完某次判断可以进一步缩短结果的范围

l=1;r=n;先看看长度为mid的有没有重复，没有的话就找小于mid的子串。

有重复子串，（为什么不看小的，因为一定会有更小的重复子串），就去找大的非重复子串。

#include<bits/stdc++.h>
using namespace std;
//1460. 我在哪 二分的思想
const int N=1e2+10;
string s;
string a;
int n;
unordered_set<string>se;
bool check(int mid)
{
    //要记住：i+mid-1
    se.clear();
    for(int i=0;i+mid-1<n;i++)
    {
        a=s.substr(i,mid);
        if(se.count(a))
        {
            return false;
        }
        else
        {
            se.insert(a);
        }
    }
    return true;
}
int main()
{
    cin>>n>>s;
    int l=1,r=n;//为什么这样设置边界：因为答案的范围就是这个
    while(l<r)
    {
        int mid=(l+r)/2;
        if(check(mid))r=mid;//没有重复的
        else l=mid+1;//有重复的；
    }
    cout<<l<<endl;
}

// 789 数的范围

二分的本质就是把一些解决给一步一步剔除掉

求x第一个出现的位置，就要把小于x的剔除掉。

求x最后一个出现的位置，就把大于x的剔除掉。

但是在剔除掉大于x的数的时候。按照刚才的思想存在一个bug：
2 2这种情况的时候，mid为l，但是结果还是小于等于x，mid又被赋值为l。导致死循环。

解决方法：求mid的时候上取整。

（自己写的时候又忘了上取整）了。

#include<bits/stdc++.h>
using namespace std;
//789. 数的范围
const int N=1e5+10;
int a[N];
int n,q;
void findd(int x)
{
    int l=1,r=n;
    //找左边界
    while(l<r)
    {
        int mid=(l+r)/2;
        if(a[mid]<x)l=mid+1;
        else r=mid;
    }
    if(a[l]!=x)cout<<"-1 -1"<<endl;
    else
    {
        cout<<l-1<<" ";
        l=1,r=n;
        while(l<r)
        {
            int mid=(l+r+1)/2;
            if(a[mid]>x)r=mid-1;
            else l=mid;
        }
        cout<<l-1<<endl;

    }

}
int main()
{
    cin>>n>>q;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=0;i<q;i++)
    {
        int x;
        cin>>x;
        findd(x);
    }

}

//四平方和

自己开始做的无法过 36 这个点（思路是有问题的）

向利用二分找到最大的数而且其平方不超过n，找到这个数，然后将其平方在n中减出去。

再次进行二分。这样有些数是可以的，有些会一直循环下去，导致出现很多1

#include<bits/stdc++.h>
using namespace std;
//1221. 四平方和
typedef long long  LL;
const int N=5e6+10;
int a[N];
LL n;
//每次都找最大的根
LL findd(LL x)
{
    LL l=1,r=x;
    LL mid;
    while(l<r)
    {
        mid=(l+r)>>1;
        if(mid^2>x)r=mid-1;
        else l=mid;
        cout<<"是否运行"<<endl;
    }
    return mid;

}
int main()
{
    cin>>n;
    int pos=0;
    while(n)
    {
        LL t=findd(n);
        a[pos++]=t;
        n-=(t*t);

    }
    while(pos!=3)
    {
        a[pos++]=0;
    }
    sort(a,a+pos+1);
    for(int i=0;i<=pos;i++)
    {
        cout<<a[i]<<" ";
    }
}

y的二分做法：

因为要求abcd联合主键排序。所以思路就是按照ab先从0开始的类似的排布。然后看n减去这两个的平方和后的数，再按照cd的顺序去找。

这种方式找到的就是，排序排好的。还要提前处理一下cd，使其按照cd顺序排序。

注意由于二分最后的条件是l<r，所以最后千万不要拿mid作为最后结果，lr相等的时候，已经不进入循环了。

另外一个思路：使用unordered_map<int,pair<int,int>>看看前面有没有cd对应

#include<bits/stdc++.h>
using namespace std;
//1221. 四平方和
const int N=5e6+10;
int pos=0,n,mid;
struct Range
{
    int s,c,d;
    bool operator<(const Range &W) const
    {
        if(s!=W.s)return s<W.s;
        if(c!=W.c)return c<W.c;
        return d<W.d;
    }
}range[N*2];

int main()
{
    cin>>n;
    for(int c=0;c*c<=n;c++)
    {
        for(int d=c;d*d+c*c<=n;d++)
        {
            int sum=d*d+c*c;
            range[pos++]={sum,c,d};
        }
    }
    sort(range,range+pos);
    for(int a=0;a*a<=n;a++)
    {
        for(int b=a;b*b+a*a<=n;b++)
        {
            int t=n-b*b-a*a;
            //现在要在有序集合中找到t这个数，最左边的那个
            int l=0,r=pos-1;
            while(l<r)
            {
                mid=(l+r)>>1;
                if(range[mid].s<t)l=mid+1;
                else r=mid;
            }
            if(range[l].s==t)
            {
                cout<<a<<" "<<b<<" "<<range[l].c<<" "<<range[l].d<<endl;
                return 0;

            }

        }
    }
}

//1227分巧克力

没有思路……

能想到的无非是巧克力的边长和分到的块数这两个数据。块数>=k的。这样就可以想到一直剔除巧克力的长度的思路。

在check判断部分，我们是为了找最大块的巧克力，也就是剔除右边界，所以先判断t<k，巧克力太大了，r=mid-1。既然是右边界，就要注意上取整。

#include<bits/stdc++.h>
using namespace std;
//1227 分巧克力
const int N=1e5+10;
int n,k;
int h[N],w[N];

int main()
{
    cin>>n>>k;
    for(int i=0;i<n;i++)cin>>h[i]>>w[i];
    int l=1,r=100000;
    while(l<r)
    {
        int mid=(l+r+1)>>1;
        int t=0;
        for(int i=0;i<n;i++)
        {
            //能切开几块正方形
            t+=(h[i]/mid)*(w[i]/mid);
        }
        //想明白是找左边界还是右边界
        //切少了
        if(t<k)r=mid-1;
        //切多了
        else l=mid;
    }

    cout<<r;
    return 0;

}