SDNU_ACM_ICPC_2021_Winter_Practice_2nd [个人赛]

其他 2021-01-22 20:04:20 阅读次数: 0

SDNU_ACM_ICPC_2021_Winter_Practice_2nd [个人赛]

传送门

A - Different Divisors

题意：

输入一个数x，让你找到一个至少有四个因子且这四个因子的大小差至少为x的一个最小的数

思路：

首先我们假设要求的这个数是ans，要让她最小，则其中四个因子的两个就是1和ans本身，这样我们只需要找到剩下的两个因子a，b；使得1，a，b三个数直接的大小差至少为x即可。但是，如果你找的a和b是一个合数，那这个合数至少有一个小于本身且不同于1和它本身的一个因子，这个因子也一定是ans的因子，这样的话就不能让1和这个因子的大小差不小于x了，所以说我们必须要找素数。

第一步先打个素数表，然后再进行一次循环，找两个满足条件的数就break掉

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
ll tr[100005];
inline int IntRead()
{
    
    
    char ch = getchar();
    int s = 0, w = 1;
    while(ch < '0' || ch > '9')
    {
    
    
        if(ch == '-')
            w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
    
    
        s = s * 10 + ch - '0',
        ch = getchar();
    }
    return s * w;
}
bool is_prime(ll n)///素数判定，用来打表的
{
    
    
    if(n == 1)  return 1;
    for(int i = 2; 1ll * i * i <= n; ++i)
    {
    
    
        if(n % i == 0)  return 0;
    }
    return 1;
}
int main()
{
    
    
    ll len = 0;
    for(int i = 1; i <= 100005; i++)//打表
    {
    
    
        if(is_prime(i) == 1)
            tr[len++] = i;
    }
    ll n, t;
    //cout<<tr[0];
    t = IntRead();
    while(t--)
    {
    
    
        n = IntRead();
        ll a = 1, ans = 1, sum = 0;//a是指上一个的因子，ans是我们最终的结果，sum用来计数
        for(int i = 1; i < 100005; i++)
        {
    
    
            if(tr[i] - a >= n)
            {
    
    
                ans *= tr[i];//如果找到了就乘起来
                a = tr[i];//更新a的值
                sum++;//用来计数
            }
            if(sum == 2)//满两个数就退出循环
            {
    
    
                cout<<ans<<endl;
                break;
            }
        }
    }
    return 0;
}

D - 这不是签到题

题意：

原来你有两个二进制数a和b，而d是这两个二进制数按位相加，不会进位的加法，每个位最大是2，数字大的就是大，比如102 > 21 021 = 21,还有的是这个d数字不喜欢重复的东西，所以会把自身连续的重复的数字变成不重复的，比如：1211 —> 121 , 022000 —> 020。不幸的是，Mike把a弄丢了，为了让他开心，你必须找到一个a，使得d的值最大

思路：

因为是找最大的数，我们肯定是让每一位都尽可能的大，但是还得考虑不能出现重复的，因为一旦出现重复的数，你的位数就会少，肯定就会小，举个栗子：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NplKObvH-1611294095896)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210121193045890.png)]

b是001011，要让d最大，那么a的第一位绝对是1，这个时候d的第一位是1；要防止d串去重，我们只能让a的第二位是0，所以d的第二位是0；下一个就可以不管b是几，直接让a取最大，也就是a的第三位是1，这个时候d的第三位是1+1也就是2；因为第三位是2，我们要避免第四位也是2而被去重了，所以就要看b串的第四位是0，我们就让a的第四位是1，所以d的第四位是1……就这样一直判断下去

脱离这个例子，我们会发现d的第i位是由d的第i-1位和b的第i位这两个数来决定的，所以可以分情况讨论一下：

当d的第i-1位是2的时候，如果bi是0，则ai取1，如果bi是1，则ai取0。

当d的i-1位是1的时候，如果bi是0，则ai取0,；如果bi是1，则ai取1

当d的第i-1位是0的时候，就可以不用管bi的值，直接让ai取1。

记得每次都要更新ai，bi，di的值

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
inline int IntRead()
{
    
    
    char ch = getchar();
    int s = 0, w = 1;
    while(ch < '0' || ch > '9')
    {
    
    
        if(ch == '-')
            w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
    
    
        s = s * 10 + ch - '0',
        ch = getchar();
    }
    return s * w;
}
int main()
{
    
    
    int t, n, a, b,c;
    string s;
    t = IntRead();
    while(t--)
    {
    
    
        n = IntRead();
        cin>>s;
        c = 1;
        b = s[0] - '0';
        a = (s[0] - '0') + c;
        printf("%d",c);
        //cout<<a<<' '<<b<<' '<<c<<endl;
        for(int i = 1; i < s.size(); i++)
        {
    
    
            b = s[i] - '0';
            if(a == 1)
            {
    
    
                if(b == 0)
                {
    
    
                    c = 0;
                    printf("0");

                }
                else
                {
    
    
                    c = 1;
                    printf("1");
                    //cout<<1;
                }

            }
            else if(a == 2)
            {
    
    
                if(b == 1)
                {
    
    
                    c = 0;
                    printf("0");
                    ///cout<<c;
                }
                else
                {
    
    
                    c = 1;
                    printf("1");
                    //cout<<c;
                }
            }
            else if(a == 0)
            {
    
    
                c = 1;
                printf("1");
                //cout<<c;
            }
            a = b + c;
            //cout<<a<<' '<<b<<' '<<c<<endl;
        }
        cout<<endl;
    }
    return 0;
}

G - A Simple Problem with Integers

线段树区间修改加区间查询的板子题

本来抱着wa的心态把之前wa了的板子打上去了，只不过这次把所有的int全换成了ll，结果AC了，可给我高兴坏了.jpg

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
//#define endl '/n'
//#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
typedef long long ll;
inline int IntRead()
{
    
    
    char ch = getchar();
    int s = 0, w = 1;
    while(ch < '0' || ch > '9')
    {
    
    
        if(ch == '-') w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
    
    
        s = s * 10 + ch - '0',
        ch = getchar();
    }
    return s * w;
}
ll tr[100005], d[400005], b[400050];
ll n, a, f, c, k, q;
void built(ll s, ll t, ll p)
{
    
    
    if(s == t)
    {
    
    
        d[p] = tr[s];
        return;
    }
    ll m = (s + t) / 2;
    built(s, m, p * 2);
    built(m + 1, t, p * 2 + 1);
    d[p] = d[p * 2] + d[p * 2 + 1];
}
void update2(ll l, ll r, ll c, ll s, ll t, ll p)
{
    
    
    if(l <= s && t <= r)
    {
    
    
        d[p] += c * (t - s + 1);
        b[p] += c;
        return;
    }
    ll m = (s + t) / 2;
    if(b[p])
    {
    
    
        d[p * 2] += b[p] * (m - s + 1);
        d[p * 2 + 1] += b[p] * (t - m);
        b[p * 2] += b[p];
        b[p * 2 + 1] += b[p];
        b[p] = 0;
    }
    if(l <= m)
        update2(l, r, c, s, m, p * 2);
    if(r > m)
        update2(l, r, c, m + 1, t, p * 2 + 1);
    d[p] = d[p * 2] + d[p * 2 + 1];
}


ll getsum2(ll l, ll r, ll s, ll t, ll p)
{
    
    
    if(l <= s && t <= r)
    {
    
    
        return d[p];
    }
    ll m = (s + t) / 2;
    if(b[p])
    {
    
    
        d[p * 2] += b[p] * (m - s + 1);
        d[p * 2 + 1] += b[p] * (t - m);
        b[p * 2] += b[p];
        b[p * 2 + 1] += b[p];
        b[p] = 0;
    }
    ll sum = 0;
    if(l <= m)
        sum += getsum2(l, r, s, m, p * 2);
    if(r > m)
        sum += getsum2(l, r, m + 1, t, p * 2 + 1);
    return sum;
}

int main()
{
    
    
    char a;
    n = IntRead();
    q = IntRead();
    for(int i = 1; i <= n; i++)
        tr[i] = IntRead();
    built(1, n, 1);
    while(q--)
    {
    
    
        cin>>a;
        if(a == 'Q')
        {
    
    
            f = IntRead();
            c = IntRead();
            cout<<getsum2(f, c, 1, n, 1)<<'\n';
        }
        else
        {
    
    
            f = IntRead(), c = IntRead(), k = IntRead();
            update2(f, c, k, 1, n, 1);
//            for(int i = 1; i <=  10; i++)
//                cout<<d[i]<<' ';
        }
    }
    return 0;
}

H - 最少拦截系统

题意：

导弹拦截系统发射的炮弹第一次可以到达任意高度，该系统之后所能达到的高度不会高于上次拦截的高度，问你需要几套系统能完全拦截导弹

思路：

当时我一看这个题，就寻思这不是那动态规划嘛，之前比较懒没学，就直接跳过了，做到后面发现这是动态规划吗，怎么做出来十几个人，就感觉不对劲，就不抱希望地回头仔细读题，却发现可以直接贪心做

我是先取了一个数组d，用来存需要的拦截系统，最坏的情况下是一个炮弹比一个高，所以数组得开三万，初始只有一个系统，其值为第一个炮弹的高度，两个for循环，外循环是对炮弹的高度 tr[i] ，内循环是对出现的系统的高度d[j]，如果tr[i] > 所有的d[j]，说明前面的所有系统都不好使了，需要一个新系统，这个新系统的d[len++] = tr[i]；如果tr[i] < 某一个的d[j]，说明第j个系统能拦住他，就可以更新一下这个d[j] 的值为tr[i]。最后只需要输出数组的长度即可

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
inline int IntRead()
{
    
    
    char ch = getchar();
    int s = 0, w = 1;
    while(ch < '0' || ch > '9')
    {
    
    
        if(ch == '-')
            w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
    
    
        s = s * 10 + ch - '0',
        ch = getchar();
    }
    return s * w;
}
int tr[30005], d[30005];
int main()
{
    
    
    int n;
    while(cin>>n)
    {
    
    
        for(int i = 1; i <= n; i++)
            tr[i] = IntRead();
        d[1] = tr[1];
        int len = 1, k = 0;//数组长度为len，初始为1，k用来判断是否需要新系统
        for(int i = 2; i <= n; i++)
        {
    
    
            k = 0;//每次循环都要初始化k的值
            for(int j = 1; j <= len; j++)
            {
    
    
                if(tr[i] <= d[j])
                {
    
    
                    d[j] = tr[i];
                    k = 1;
                    break;//找到了就跳出，进行下一个炮弹的拦截
                }
            }
            if(k == 0)//k == 0说明没找到能拦截的系统，就得添加新系统
            {
    
    
                d[++len] = tr[i];
            }
        }
        cout<<len<<endl;
    }
    return 0;
}

I - How Many Tables

并查集板子题，但是记得要初始化数组，一不小心就wa了.jpg

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
inline int IntRead()
{
    
    
    char ch = getchar();
    int s = 0, w = 1;
    while(ch < '0' || ch > '9')
    {
    
    
        if(ch == '-')
            w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
    
    
        s = s * 10 + ch - '0',
        ch = getchar();
    }
    return s * w;
}
int tr[10005];
int find1(int x)
{
    
    
    if(tr[x] == x)
        return x;
    if(tr[x] != x)
    {
    
    
        tr[x] = find1(tr[x]);
        return tr[x];
    }
}
void ran(int a, int b)
{
    
    
    int x = find1(a);
    int y = find1(b);
    if(x != y)
        tr[y] = x;
}
int main()
{
    
    
    int n, m, a, b, t;
    t = IntRead();
    while(t--)
    {
    
    
        int sum = 0;
        memset(tr, 0, sizeof(tr));
        n = IntRead();
        m = IntRead();
        for(int i = 1; i <= n ; i++)
        {
    
    
            tr[i] = i;
        }
        for(int i = 1; i <= m; i++)
        {
    
    
            a = IntRead();
            b = IntRead();
            ran(a, b);
        }
        for(int i = 1; i <= n; i++)
        {
    
    
            if(tr[i] == i)
                sum++;
        }
        printf("%d\n",sum);
        //cout<<sum<<endl;
    }
    return 0;


}

M - Intersecting Lines

题意：

给你四个点，（x1,y1）（x2,y2）（x3,y3）（x4,y4），前两个点构成一条直线，后两个点构成一条直线，问你这两条直线 位置关系

思路：

看起来挺简单的，其实你得对解析几何了解的比较透彻才行

我用的是最老土的办法：设直线，推公式，而非那些花里胡哨的向量计算法（好吧，其实是我忘了向量那些公式是什么了……手动狗头

相信学过高中数学的同志们都知道考试最后一个解析几何的题，基本上都要考虑斜率不存在的特殊情况！

对，这个题你得先考虑斜率不存在的时候，两个直线的斜率都不存在的时候，你还得判断这两条直线是不是同一条直线（我就是wa在了这里！！！当时想了半天都觉得自己思路没问题，后来就下定决心如果再找不出错就去吃饭，结果一不小心找到了.jpg），判断完斜率不存在之后就可以直接算k1,b1,k2,b2，然后推个公式带进去即可。还要注意题目对输出的一些要求就能AC。

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
int main()
{
    
    
	int n;
    double  x1, x2, x3, x4, y1, y2, y3, y4;
    scanf("%d",&n);
    printf("INTERSECTING LINES OUTPUT\n");
    while(n--)
    {
    
    
      scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4);

        if(x1 == x2 && x3 == x4)//同时没有斜率
        {
    
    
        	if(x1 == x3)//判断是不是重合了
        		cout<<"LINE"<<endl;
        	else
        		cout<<"NONE"<<endl;
        }
        else if(x1 == x2 && x3 != x4)//一个有斜率一个没有斜率
        {
    
    
            double k2,b2,x,y;
            k2 = (y4 - y3) / (x4 - x3);//公式，手推
            b2 = (x4 * y3 - x3 * y4) / (x4 - x3);
            x = x1;
            y = k2 * x + b2;
            printf("POINT ");
            printf("%.2lf %.2lf\n", x, y);
//            cout<<x<<' '<<y<<endl;
        }
        else if(x1 != x2 && x3 == x4)//同样是一个有斜率一个没有
        {
    
    
            double k1,b1,x,y;
            k1 = (y2 - y1) / (x2 - x1);
            b1 = (x2 * y1 - x1 * y2) / (x2 - x1);
            x = x3;
            y = k1 * x + b1;
            printf("POINT ");
            printf("%.2lf %.2lf\n", x, y);
            //cout<<x<<' '<<y<<endl;
        }
        else
        {
    
    
            double k1, k2, b1, b2, x, y;
            k1 = (y2 - y1) / (x2 - x1);
            k2 = (y4 - y3) / (x4 - x3);
            b1 = (x2 * y1 - x1 * y2) / (x2 - x1);
            b2 = (x4 * y3 - x3 * y4) / (x4 - x3);
            if(k1 == k2)//斜率相同则进行进一步的判断
            {
    
    
                if(b1 == b2)//重合
                    printf("LINE\n");
                else if(b1 != b2)
                    printf("NONE\n");
            }
            else
            {
    
    
                x = (b2 - b1) / (k1 - k2);
                y = k1 * x + b1;
                printf("POINT ");
                printf("%.2lf %.2lf\n",x, y);
            }
        }
    }
	printf("END OF OUTPUT\n");
    return 0;
}

J - The Suspects

题意：

0号同学有带病毒的嫌疑，给你n个团体，如果团体内有一个人有嫌疑，则整个团体都有嫌疑，问有多少带病毒嫌疑的人

思路：

并查集的变形，因为0号有嫌疑，最后要求所有带病毒嫌疑的人，就可以利用并查集合并并查找0号个体所在的团体，最终输出该团体的人数即可。

又因为是0号有嫌疑，是最小的一号，我们就可以采用取小原则，而非之前的靠左原则，即合并的时候谁的号小就归顺谁，这样能保证头领是0号，然后查找的时候只需要找他的头领是不是0号即可！

#include <bits/stdc++.h>
using namespace std;
const int N = 30000 + 5;
int n, m, k, tr[N];//
void init()//初始化数组
{
    
    
    for(int i = 0; i < n; ++i)
    {
    
    
        tr[i] = i;
    }
}
int find1(int v)//俗称找爹函数
{
    
    
    if(f[v] == v)//找到了就返回爹
        return v;
    else//没找到就继续找爹
    {
    
    
        f[v] = find1(f[v]);
        return f[v];
    }
}
void ranran(int u, int v)//合并
{
    
    
    int x = find1(u);//先把x，y的爹找出来
    int y = find1(v);
    if(x < y)//取小原则
        f[y] = x;
    else if(x > y)
        f[x] = y;
}
int a, b, c, sum;//sum用来计数，记得要清0
int main()
{
    
    
    while(cin>>n>>m)
    {
    
    
        if(n == 0 && m == 0)//输入都是0的时候结束程序
            break;
        init();//初始化
        sum = 0;//清0
        while(m--)//m组例子
        {
    
    
            cin>>a>>b;
            a--;//a个数,而b就是a个数中的一个，所以写while之前得让a--
            while(a--)
            {
    
    
                cin>>c;
                ranran(b, c);//每一次都A1与Ai进行并查集操作
            }
        }
        for(int i = 0; i < n; i++)
        {
    
    
            if(f[i] == 0 || find1(i) == 0)//两种情况，一种是本身就是0，另一种是认的爹是0
                sum++;
        }
        cout<<sum<<endl;
    }
    return 0;
}

B - String LCM

题意：

给你n对字符串，让你判断两个串的“最小公倍数”，如：abab 与 ab的最小公倍数是abab，如果没有的话就输出-1

代码如下，具体思路我会单独开一个博客写

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using namespace std;
int next1[100005],next2[100005], len1, len2;
string s1, s2;
void getnext1()
{
    
    
    int j, k;
    j = 0;
    k = -1;
    next1[0] = -1;
    while(j < len1)
    {
    
    
        if(k == -1 || s1[j] == s1[k])
            next1[++j] = ++k;
        else
            k = next1[k];
    }
}
void getnext2()
{
    
    
    int j, k;
    j = 0;
    k = -1;
    next2[0] = -1;
    while(j < len2)
    {
    
    
        if(k == -1 || s2[j] == s2[k])
            next2[++j] = ++k;
        else
            k = next2[k];
    }
}
int gcd(int a, int b)
{
    
    
    if(b) return gcd(b, a % b);
    else return a;
}
int main()
{
    
    
    int n, a, b, k;
   // string s1, s2;
    cin>>n;
    while(n--)
    {
    
    
        memset(next1, 0, sizeof(next1));
        memset(next2, 0, sizeof(next2));
        k = 1;
        cin>>s1>>s2;
        len1 = s1.size();
        len2 = s2.size();
        getnext1();
        getnext2();
        a = len1 - next1[len1];
        b = len2 - next2[len2];
        if(len1 % a != 0)
            a = len1;
        if(len2 % b != 0)
            b = len2;
//        for(int i = 1; i <= len1; i++)
//            cout<<next1[i]<<' ';
 //       cout<<len1 - next1[len1 - 1]<<endl<<len2 - next2[len2 - 1];
        if(a != b || len1 % a != 0 || len2 % b != 0)
        {
    
    
//            cout<<a<<' '<<b<<endl<<len1<<' '<<len2;
//            cout<<"第一处"<<endl;
            cout<<-1;
        }
        else
        {
    
    
            for(int i = 0; i < a; i++)
            {
    
    
                if(s1[i] != s2[i])
                {
    
    
                    k = 0;
                    break;
                }
            }
            if(k == 0)
            {
    
    
                cout<<-1;
            }
            else
            {
    
    
                int c = (len1 / a * len2 / b) / gcd(len1 / a, len2 / b);
                while(c--)
                {
    
    
                    for(int i = 0; i < a; i++)
                        cout<<s1[i];
                }
            }
        }
        cout<<endl;
    }
    return 0;
}

}

总结：

A题：思维题，最少四个因子，代表你只需要找两个因子即可，再仔细分析一下就知道是找素数因子

B题: KMP的next数组的思维题（我是真没想到是KMP的题.jpg

D题：01字符串的问题，题干很长，看似很难，其实不难，就是第一位一定是1，然后下面每一位都判断选1的时候加起来和上一位一不一样，不一样就选1，一样就选0

G题：线段树区间查询区间修改，套板子即可

H题：贪心，每次从第一个系统开始判断，如果能拦住就更新一下，拦不住就再找一个系统，最后输出总系统的个数

I题：并查集板子

J题：并查集的升级版，根据题意改一下find函数，将以左为尊改为以小为尊

M题：给你四个点，前两个点确定一条直线，后两个点确定一条直线，问你这两条直线的位置关系，题目不难，就是细节比较多，判斜率不存在和斜率存在，在分别判是平行还是重合还是相交，特别注意不要忘了判两个直线都没斜率的时候是否重合，剩下的的就考的是数学知识，推个公式即可

猜你喜欢

转载自blog.csdn.net/weixin_51216553/article/details/112982728
今日推荐
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
最强开源大模型 Llama 3 上架 Gitee AI
虽然老乡鸡开源的不是代码，但背后的原因却让人很暖心
周排行
决策树的部分理解
STM32软件IIC的实现
RocketMQ原理解析-HA
vue-动态路由（路由的传参和接参）
利用python对Excel中的特定数据提取并写入新表
【Ubuntu】 Ubuntu16.04搭建NFS服务
Elasticsearch基础操作与对应的curl命令行，python对接实现
JVM数据存储结构 & Java的值传递和址传递
yum命令使用指南
java基础（一）：java语法基础
每日归档
更多
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)
2024-04-15(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022