2022.1.18

蓝桥杯2021c++ B组

1550

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
void solve()
{
    int cnt[10];
    for (int i = 0; i <= 9; i++) cnt[i] = 2021;
    int n = 1;
    while (1)
    {
        
        int x = n;
    //    cout << x << "x" << endl;
        while (x)
        {
            if (cnt[x % 10])
            {
                cnt[x % 10]--;
            }
            else
            {
                cout << n-1 << endl;
                return;
            }
            x /= 10;
        }
        n++;

    }

}
int main()
{
    solve();
}

1551

#include<iostream>
#include<algorithm>
#include<set>
#include<cstring>
using namespace std;
typedef pair<double, double> PI;
set<PI> ans;
void solve()
{
    
    for (int x1 = 0; x1 < 20; x1++)
    {
        for (int y1 = 0; y1 <= 20; y1++)
        {
            for (int x2 = 0; x2 < 20; x2++)
            {
                for (int y2 = 0; y2 <= 20; y2++)
                {
                    if (x1 == x2) {
                        ans.insert({ 1000000000,x1 });
                        continue;
                    }
                    double k = (double)(y2 - y1) / (x2 - x1);
                    double b = (double)(y1 * (x2 - x1) - x1 * (y2 - y1)) / (x2 - x1);
                    ans.insert({ k,b });
                }
            }
        }
    }
    cout << ans.size() << endl;
}
int main()
{
    solve();
}

1552

#include<iostream>
#include<cmath>
using namespace std;
long long int n,ans,k,a[1000000];
int main()
{
    n=2021041820210418;
    for(long long i=1;i<=sqrt(n);i++)
    {
        if(n%i==0) 
        {
            a[++k]=i;
            if(i*i!=n) a[++k]=n/i; 
        }
    }
    
    for(long i=1;i<=k;i++)
        for(long j=1;j<=k;j++)
            
                if(n/(a[i]*a[j])*a[i]*a[j]==n) ans++;
            
    cout<<ans<<endl;
}

1553

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
using namespace std;
const int N = 4e5 + 10;
int e[N], ne[N], h[N], idx, w[N];
int dist[N];
bool vis[N];
typedef pair<int, int> PI;
int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}
int lcm(int a, int b)
{
    return a * b / gcd(a, b);
}
void add(int a, int b)
{
    int len = lcm(a, b);
    e[idx] = b, ne[idx] = h[a], w[idx] = len, h[a] = idx++;
}
void dijstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PI, vector<PI>, greater<PI>> heap;
    heap.push({ 0,1 });
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int ver = t.second, dis = t.first;
        if (vis[ver]) continue;
        vis[ver] = true;
        for (int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i], len = w[i];
            if (dis + len < dist[j])
            {
                dist[j] = dis + len;
                //cout << dist[j] << " " << j << endl;
                heap.push({ dist[j],j });
            }
            
        }
    }
}
void solve()
{
    memset(h, -1, sizeof h);
    for (int i = 1; i <= 2021; i++)
    {
        for (int j = i; j <= 2021; j++)
        {
            if (abs(i - j) <= 21)
            {
                add(i, j), add(j, i);
                //cout << i << " " << j << endl;
            }
        }
    }
    dijstra();
    cout << dist[2021] << endl;
}
int main()
{
    solve();
}

1555

#include<iostream>
using namespace std;
int main()
{
    cout<<256*1024*1024/4<<endl;
}

1558

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 2e5 + 10;
int vis[N];
void solve()
{
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        int a;
        cin >> a;
        for (int j = 1; j <= 100000; j++)
        {
            if (vis[j] != i && vis[j])
            {
                if (vis[a + j] == 0) vis[a + j] = i;
                if (vis[abs(j - a)] == 0) vis[abs(j - a)] == i;
                if (vis[abs(a - j)] == 0) vis[abs(a - j)] = i;
            }
        }
        vis[a] = i;
         
    }
    for (int i = 1; i <= 100000; i++)
    {
        if (vis[i]) ans++;
    }
    cout << ans << endl;
}
int main()
{
    solve();
}

1563

#include<iostream>
#define int long long
using namespace std;
signed main()
{
    int T;
    int mod=60*60*24*1000;
    cin>>T;
    while(T--)
    {
        int time;
        cin>>time;
        time%=mod;
        time/=1000;
        int H=time/3600;
        int M=time/60%60;
        int S=time%60;
        if(H<10) cout<<0;
        cout<<H<<":";
        if(M<10) cout<<0;
        cout<<M<<":";
        if(S<10) cout<<0;
        cout<<S<<""<<endl;
    }
}

1564

题目描述

思路

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

把杨辉三角数用数组的方式表示出来可以发现从0开始计数，第i行第j个数就是c（i，j）的组合数。根据组合数的性质，对于杨辉三角我们只需要考虑左半边，观察可以得到第i行的最大值在第i/2列，其次我们枚举列数，列数为n时，最大值便是c(n,2*n)和c(n,2*n+1)。发现枚举到16时超过了1e9,因此16列就是最大列了。

可能会奇怪为什么列数不能再往右了，这是因为观察可以发现杨辉三角越往下数越大，越往右数越大，所以16列以后的所有数都是大于c(16,32)的也是无解的数据，而c(16,32)这个位置是个最大值点，往上的列数即使超过16也是无意义的重复点。

现在可以通过枚举确定列数,再通过二分确定行数(往下逐渐增大，满足单调性)

#include<iostream>
#include<algorithm>
#include<cstring>
#define int long long
using namespace std;
const int N = 5e3 + 10;
int n;
int c(int q, int p)//求组合数
{
    int res = 1;
    for (int i = 1, j = q - p + 1; i <= p; i++, j++)
    {
        res = res * j / i;
        if (res > n) return res;
    }
    return res;
}
int check(int x)
{
    int l = 2 * x, r = n, mid;
    while (l <= r)
    {
        mid = l + r >> 1;
        int num = c(mid, x);
        if (num > n) r = mid - 1;
        else if (num < n) l = mid + 1;
        else
        {
            int ans = (mid + 1) * (mid) / 2 + x + 1;
            cout << ans << endl;
            return 1;
 
        }
    }
    return 0;
}
void solve()
{
    cin >> n;
    if (n == 1)
    {
        puts("1");
        return;
    }
    for (int i = 20; i; i--)
    {
        if (check(i)) break;
    }
}
signed main()
{
    int t;
    cin >> t;
    while (t--)
    {
        solve();
    }
}

1565

题意

给定序列(a[1], a[2], ... , a[n]) = (1, 2, ... , n)，即a[i] = i。

小蓝将对这个序列进行m次操作，每次可能是将a[1], a[2], ... a[qi] 降序排列，或者将a[qi], a[qi+1], ... , a[n] 升序排列。

思路

可能会有多次连续升序操作或多次连续降序操作，这时候就会发现操作有重复，我们可以取一个最有效的操作范围，

其次可能会有升序降序相间的操作，这时候假设一个升序数列，对于(1,K)进行降序操作，那么K+1到n还是升序，这段操作不会影响K+1到n，之后再来一段(m,n)的升序操作(m<k) 可以发现，(1,k)是降序，

操作过后，(m，k) (k, n)这两段变成了升序，但是(1，m)没有被改变。

总结一下，也就是这一段数轴可以分为三段，左端由影响范围最大的操作2固定，右端由影响最大的操作1固定，中间由两者中最后一次进行操作的那种决定。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 1e5 + 10;
typedef pair<int, int>PI;
 
PI skt[N];
int ans[N];
int n, m;
void solve()
{
    int top = 0;
    scanf("%d%d", &n, &m);
    while (m--)
    {
        int p, q;
        scanf("%d%d", &p, &q);
        if (!p)
        {
            while (top && skt[top].first == 0)
            {
                q = max(q, skt[top--].second);
            }
            while (top >= 2 && skt[top - 1].second <= q)
            {
                top -= 2;
            }
            skt[++top] = { 0,q };
        }
        else if(top)
        {
            while (top && skt[top].first == 1)
            {
                q = min(q, skt[top--].second);
            }
            while (top >= 2 && skt[top - 1].second >= q)
            {
                top -= 2;
            }
            skt[++top] = { 1,q };
        }
    }
        int l = 1, r = n, num = n;
        for (int i = 1; i <= top; i++)
        {
            if (skt[i].first == 0)
            {
                while (l <= r && r > skt[i].second) ans[r--] = num--;
            }
            else
            {
                while (l <= r && l < skt[i].second) ans[l++] = num--;
            }
            if (l > r) break;
        }
        if (top % 2)
        {
            while (l <= r) ans[l++] = num--;
        }
        else while (l <= r) ans[r--] = num--;
     
    for (int i = 1; i <= n; i++)
        printf("%d ", ans[i]);
}
int main()
{
    solve();
}