NYIST-2019省赛训练个人积分赛第五场

最新推荐文章于 2019-04-06 19:02:51 发布
最新推荐文章于 2019-04-06 19:02:51 发布
阅读量121 收藏
点赞数
分类专栏： # 2019省赛集训个人和组队赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41925919/article/details/89000935
版权

A - An Equation

FZU - 1909

题目大意：
输入四个数字a,b,c,d是否其中两个数的和是否等于另外两个数的和
比赛的时候脑子瓦特了。。。。Yes打成了YES。。wa了一发。。。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int main()
{
    int T;
    int a,b,c,d,p=1;
    scanf("%d",&T);
    while(T--)
    {
        int flag=0;
        scanf("%d %d %d %d",&a,&b,&c,&d);
        if(a+b==c+d)
            flag=1;
        else if(a+c==b+d)
            flag=1;
        else if(a+d==b+c)
            flag=1;
        printf("Case %d: ",p++);
        if(flag)
            printf("Yes\n");
        else
            printf("No\n");
    }
}

·
·

B - 非主流

FZU - 1922

鸭子a1在这三只鸭子里的另类度为：dist (a1,a1)+dist (a1,a2)+dist (a1,a3)。

定义dist运算为：

dist (a1,a1)= (|1-1|+|0-0|+|0-0|+|1-1|+|0-0|) = 0

dist (a1,a2) = (|1-0|+|0-1|+|0-0|+|1-0|+|0-1|) = 4;

dist (a1,a3) = (|1-0|+|0-0|+|0-1|+|1-0|+|0-1|) = 4;

就得到鸭子a1在这三只鸭子里的另类度为8。

另类的鸭子越多，风险就越大，因此，养鸭场的老板希望可以确定他的鸭群里面到底有多少另类的鸭子。

Input
首先第一行为T，表示有T组数据。接下来为每组数据的结构：
每组数据第一行为空格隔开的三个整数n、m和p。n表示有n只鸭子(2 <= n <= 10,000)，m表示这群鸭子有m个特征值(5 <= m <= 200)，p表示另类度的界限，认为大于等于p的另类度的鸭子就为另类的鸭子(0 <= p <= 2,000,000)。

接下来n行，每行有m个用空格隔开的0或1数字，表示鸭子的特征值。

Output
对于每组数据输出一行先输出组数(从1开始)，接着输出该群鸭子中另类的鸭子数。
Sample Input
1
3 5 8
1 0 0 1 0
0 1 0 0 1
0 0 1 0 1
Sample Output
Case 1: 1

虽然说题意不太好理解，可是推一推也能推出来，先说思路吧：
n大概有10000，m有200，n2的复杂度是肯定不行的，分析一下题意，第一只鸭子的另类度也就是第一行和第二行，第一行和第三行特征值不一样的有几个，然而特征值只有0和1，所以每一列记录一下0和1的个数就好了
这道题。。。感觉全世界都想到了思路。。。只有我。。。卡死了。。。。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int e[10005][205];
int a[10005],b[10005];
int main()
{
    int n,m,P,p=1,T;
    scanf("%d",&T);
    while(T--)
    {
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        scanf("%d %d %d",&n,&m,&P);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&e[i][j]);
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(e[j][i]==0)
                    a[i]++;
                else
                    b[i]++;
            }
        }
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            int ans=0;
            for(int j=1;j<=m;j++)
            {
                if(e[i][j]==0)
                    ans+=b[j];
                else
                    ans+=a[j];
            }
            if(ans>=P)
                sum++;
        }
        printf("Case %d: %d\n",p++,sum);
    }
    return 0;
}

·
·

C - Unusual Product

CodeForces - 405C

大概题意

给你一个n*n的矩阵，矩阵的值为矩阵自乘，然而每一步的值都要mod2，每次进行m次操作
操作有三种：
1） 1 x 将第x行的0 1都反转为1 0
2） 2 x 将第y列的0 1都反转为1 0
3）3 计算矩阵的自乘值

思路

我们设一个3*3的矩阵
a1 a2 a3
a4 a5 a6
a7 a8 a9
这个矩阵的自乘值为（a1 * a1）+(a2 * a4)+(a3 * a7)+(a2 * a4)+(a5 * a5)+(a8 * a6)+(a1 * a1)+(a6 * a8)+(a9 * a9);
整理一下等于：(a1 * a1)+(a5 * a5)+(a9 * a9)+2 *(a2 * a4)+2 (a3 * a7)+2 (a8 * a6)
也就是这个矩阵的自乘值只和a1 a5 a9有关，那么反转一次，只会改变这三个数中的其中一个，所以反转一次自乘值要么从0变为1，要么从1变为0，只需要判断反转的个数，反转个数为奇数，则自乘值改变，反转个数为偶数，则自乘值不变


#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int e[10005][205];
int a[10005],b[10005];
int main()
{
    int n,m,P,p=1,T;
    scanf("%d",&T);
    while(T--)
    {
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        scanf("%d %d %d",&n,&m,&P);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&e[i][j]);
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(e[j][i]==0)
                    a[i]++;
                else
                    b[i]++;
            }
        }
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            int ans=0;
            for(int j=1;j<=m;j++)
            {
                if(e[i][j]==0)
                    ans+=b[j];
                else
                    ans+=a[j];
            }
            if(ans>=P)
                sum++;
        }
        printf("Case %d: %d\n",p++,sum);
    }
    return 0;
}

·
·

D - 填空

FZU - 1926

中文题意就不解释了。。。
就是KMP的板子题，要注意的是模式串中的 _ 是可以和任何单词匹配的
有点卡时间，用cin输入string都会超时，要用scnaf（）输入再转成string

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
string b[1005],a[1005];
char s[10000];
int nex[1005],e;
void Nex(int n)
{
    int i=0,j=-1;
    nex[0]=-1;
    while(i<n)
    {
        if(j==-1||b[i]==b[j]||b[j]=="_"||b[i]=="_")
        {
            i++;
            j++;
            nex[i]=j;
        }
        else
            j=nex[j];
    }
}
int kmp(int n)
{
    Nex(n);
    int i=0,j=0;
    while(i<e&&j<n)
    {
        if(j==-1||a[i]==b[j]||b[j]=="_")
        {
            i++;
            j++;
        }
        else
            j=nex[j];
        if(j==n)
                return 1;
    }
    return 0;
}
int main()
{
    int T,n,p=1;
    scanf("%d",&T);
    while(T--)
    {
        int k=0;
        while(1)
        {
            scanf("%s",s);
            if(strcmp(s,"@")==0)
                break;
            a[k++]=(string)s;
        }
        e=k;
        scanf("%d",&n);
        printf("Case %d:\n",p++);
        while(n--)
        {
            k=0;
            while(1)
            {
                scanf("%s",s);
                if(strcmp(s,"@")==0)
                    break;
                b[k++]=(string)s;
            }
            if(kmp(k))
                printf("YES\n");
            else
                printf("NO\n");
        }
    }
    return 0;
}

·
·

E - 死锁

FZU - 1924

中文的题意。。很容易看懂，而且题中已经把思路说出来了，就是看自己能不能回到自己
让我有点惊讶的是，爆搜竟然过了。。。
先建图，建图之后枚举每个点，每个点开始搜，看能不能搜到自己

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int f[1005],tot,u,flag,vis[1005];
struct node
{
    int v,nex;
};
node e[1000005];
void add(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=f[u];
    f[u]=tot++;
}
void dfs(int k)
{
    if(flag)
        return ;
    for(int i=f[k]; i!=-1; i=e[i].nex)
    {
        int v=e[i].v;
        if(v==u)
        {
            flag=1;
            return ;
        }
        if(!vis[v])
        {
            vis[v]=1;
            dfs(v);
        }
    }
}
int main()
{
    int T,p=1;
    int n,m,a,b;
    scanf("%d",&T);
    while(T--)
    {
        flag=0;
        tot=0;
        memset(f,-1,sizeof(f));
        int x,y;
        scanf("%d %d %d %d",&n,&m,&a,&b);
        for(int i=1; i<=a; i++)
        {
            scanf("%d %d",&x,&y);
            add(x,y+n);
        }
        for(int i=1; i<=b; i++)
        {
            scanf("%d %d",&x,&y);
            add(x+n,y);
        }
        for(int i=0; i<n+m; i++)
        {
            memset(vis,0,sizeof(vis));
            vis[i]=1;
            u=i;
            dfs(i);
            if(flag)
                break;
        }
        printf("Case %d: ",p++);
        if(flag)
            printf("Possible\n");
        else
            printf("Impossible\n");
    }
    return 0;
}

·
·

F - shadow

FZU - 2169

思路

比赛的时候想着跑最短路来着。。。算了一下感觉要超时，就没有打，但是好像spfa是可以过的，其实不用那么麻烦，我们从点1开始，广搜，把每个点的父亲节点都存储起来，然后再从那k个点往1节点回溯，还有一个可以剪枝的点就是，如果跑到了之前的点走过的节点，就不用往前搜了，因为走的路都是一样的。（刚开始的时候每个点的父亲节点是它自己）

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<math.h>
#include<vector>
#include<queue>
using namespace std;
int a[100005],f[100005],tot,vis[100005];
int g[100005],b[100005];
struct node
{
    int v,nex;
};
node e[500005];
void add(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=f[u];
    f[u]=tot++;
}
void dfs()
{
    queue<int>q;
    q.push(1);
    vis[1]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=f[u];i!=-1;i=e[i].nex)
        {
            int v=e[i].v;
            if(!vis[v])
            {
                vis[v]=1;
                g[v]=u;
                q.push(v);
            }
        }
    }
}
int main()
{
    int n,m,x,y;
    while(~scanf("%d %d",&n,&m))
    {
        tot=0;
        memset(f,-1,sizeof(f));
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
          {
              g[i]=i;
              scanf("%d",&a[i]);
          }
        for(int i=1;i<=m;i++)
            scanf("%d",&b[i]);
        for(int i=1;i<=n-1;i++)
        {
            scanf("%d %d",&x,&y);
            add(x,y);
            add(y,x);
        }
        dfs();
        int ans=0;
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=m;i++)
        {
            int k=b[i];
            while(1)
            {
                if(vis[k]||k==1)
                    break;
                if(!vis[k])
                {
                    vis[k]=1;
                    ans+=a[k];
                }

                k=g[k];
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

·
·

G - Domino Effect

CodeForces - 405B

题意

题描述的是多米诺骨牌，输入的是行字符串只有三种字符‘L’，‘R’，‘.’如果是’.'意味着这里有一块多米诺骨牌，如果是‘R’意味着这个多米诺骨牌向右边倒，如果是‘L’意味着这个多米诺骨牌向左边倒，问你最后还剩多少张多米诺骨牌是直立着的（当左边右两遍的骨牌都向中间倒，如果两遍倒的骨牌数量是一样的，则这个骨牌是可以直立的）

思路

看了题之后感觉模拟过程有点复杂，在网上看到了一个思路感觉特别的好：用一个数组在记录这个骨牌左右两边倒的个数，向左倒就叠加加1，向右倒叠加减1
例如;
. . . L . . . R .L
数组记录为-3 -2 -1 L 0 0 0 R 0 L 数组中的数位0则说明这个骨牌是直立的

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
char s[3005];
int e[3005];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        memset(e,0,sizeof(e));
        scanf("%s",s);
        for(int i=0;i<n;i++)
        {
            if(s[i]=='L')
            {
                for(int j=1,k=i-1;k>=0&&s[k]=='.';j++,k--)
                    e[k]+=j;
            }
            else if(s[i]=='R')
            {
                for(int j=1,k=i+1;k<n&&s[k]=='.';j++,k++)
                    e[k]-=j;
            }
        }
        int cnt=0;
        for(int i=0;i<n;i++)
        {
            if(e[i]==0&&s[i]=='.')
               {
                   //printf("%d\n",i);
                   cnt++;
               }
        }
        printf("%d\n",cnt);
    }
    return 0;
}

·
·

H - 栀子花开

FZU - 1921

题意就不解释了，看到题之后就觉得是个点更新的线段树，敲了一个板子就过了。。。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct node
{
    int id,sum;
};
node e[100005];
int a[10005];
void build(int root,int l,int r)
{
    if(l==r)
    {
        e[root].id=l;
        e[root].sum=a[l];
    }
    else
    {
        build(root*2,l,(l+r)/2);
        build(root*2+1,(l+r)/2+1,r);
        if(e[root*2].sum>e[root*2+1].sum)
        {
            e[root].sum=e[root*2+1].sum;
            e[root].id=e[root*2+1].id;
        }
        else
        {
            e[root].sum=e[root*2].sum;
            e[root].id=e[root*2].id;
        }
    }
}
void update(int x,int y,int l,int r,int root)
{
    if(l==r)
    {
        e[root].sum+=y;
    }
    else
    {
        if(x<=(l+r)/2)
            update(x,y,l,(l+r)/2,root*2);
        else
            update(x,y,(l+r)/2+1,r,root*2+1);
        if(e[root*2].sum>e[root*2+1].sum)
        {
            e[root].sum=e[root*2+1].sum;
            e[root].id=e[root*2+1].id;
        }
        else
        {
            e[root].sum=e[root*2].sum;
            e[root].id=e[root*2].id;
        }
    }
}
int main()
{
    int T,n,p=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
            scanf("%d",&a[i]);
        build(1,1,n);
        int m,x,y;
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d %d",&x,&y);
            if(x==0)
             x=e[1].id;
            update(x,y,1,n,1);
        }
        printf("Case %d: %d %d\n",p++,e[1].id,e[1].sum);
    }
    return 0;
}

·
·

I - Gravity Flip

CodeForces - 405A

题意

有n个长直柱体，每个直柱体都是由若干个小立方体摞起来的，刚开始的时候重力是向下的，这些小立方体都直立的排在一起，问你，当重力的方向改变为向右之后，每个直柱体上的小立方体有几个
啊。。。这个题是我的读题有问题吗。。比赛的时候，人家看了样例就猜出来题意了，我把题读了n遍才搞出来题意
就是个模拟。。。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int a[100];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
        scanf("%d",&a[i]);
    while(1)
    {
        int flag=0;
        for(int i=n-1; i>=1; i--)
        {
            int t=i;
            for(int j=i+1; j<=n; j++)
            {
                //printf("%d\n",j);
                if(a[i]>a[j])
                {
                    flag=1;
                    t=j;
                }
            }
            if(t>i)
            {
                int k=a[i]-a[t];
                a[i]-=k;
                a[t]+=k;
            }
        }
        if(!flag)
            break;
    }

    for(int i=1; i<=n; i++)
    {
        printf("%d%c",a[i],i==n?'\n':' ');
    }
    return 0;
}

·
·
这场比赛打的我心态崩崩的。。。。题都不是很难，但是就是打的不好，有些题没敢写，有些题卡出发际线。。。那个鸭子那个题（第二题）竟然没有写出来。。我的天啊。。。好难受。。。总结就是自己太菜了太菜了。。。。。。

这里是一只小小琪
关注
专栏目录
2020NYIST个人积分赛第六场 D
01-03
题意： 给n个点,m条边,让构建一个有向无环无重边的图，并且图的最短路是素数，最小生成树也是素数。 思路： 题意的可塑造性很强，我们可以让最小生成树就是最短路，呢么我们现在就是给最小生成树找一个素数，很明显...
2020NYIST个人积分赛第四场(线段树+前缀 后缀乘积和）
01-03
题意： 给n个位置，q次操作，每次对操作可以改变i位置的数，定义f(i,j)=ai∗a(i+1)∗…∗aj.f(i,j) = ai * a(i+1) * … * aj.f(i,j)=ai∗a(i+1)∗…∗aj. 求整个区间中所有子区间乘积的和对10007取模 ...
南阳理工学院省赛集训组队赛（第五场）
nyist_acm的博客
04-26 196
比赛链接A：B：C：D：E：F：提供人：聂海隆 题解链接：https://blog.csdn.net/nhl19961226/article/details/80097105G：提供人：程天祥 题解链接：https://blog.csdn.net/xiangAccepted/article/details/80097652H：I：提供人：高胤润 题解链接：https://blog.csdn.net...
南阳理工学院省赛集训（第五场）
nyist_acm的博客
04-03 438
题目链接A：提供人：贺鹏程 题解链接：https://blog.csdn.net/riba2534/article/details/79816413B：提供人：赵育琪 题解链接：https://blog.csdn.net/team39/article/details/79810172C：提供人：劳国平 题解链接：https://blog.csdn.net/weixin_41380961/artic...
HDU-5971 Wrestling Match (2016ACM/ICPC亚洲区大连站)
NYIST_TC_LYQ的博客
09-26 440
Wrestling Match 被这个题坑了一下午，强烈吐槽出题人卡stack是几个意思啊，只能用dfs或bfs。并查集都不让用的，RE了一下午。数据还这么水，POJ-1703 数据量1e5都不会爆栈的啊。 还有题目说好了65536kb，1e6的数组都MLE。。。 题意：n个人有m个敌对关系，两个确定的集合都有一定的人，求是否能把这n个人全部分为两个集合。 典型的种类并查集，开始用df
NYIST-2019省赛训练个人积分赛第二场
qq_41925919的博客
04-01 209
A - Dinner NBUT - 1217 题意 给你n个单词，从中找出和厨具有关的单词。 厨具有关的单词只有四个：bowl, knife, fork and chopsticks 很简单，就直接模拟就好了，控制一下输出的格式，比赛的时候没管太多。。代码写的有点长。。。 #include<stdio.h> #include<string.h> #include<al...
NYIST-2019省赛训练个人积分赛第一场
qq_41925919的博客
03-28 182
A - 打牌 HDU 1584 Problem Description 蜘蛛牌是windows xp操作系统自带的一款纸牌游戏，游戏规则是这样的：只能将牌拖到比她大一的牌上面（A最小，K最大），如果拖动的牌上有按顺序排好的牌时，那么这些牌也跟着一起移动，游戏的目的是将所有的牌按同一花色从小到大排好，为了简单起见，我们的游戏只有同一花色的10张牌，从A到10，且随机的在一行上展开，编号从1到10，把...
NYIST-2019省赛训练组队积分赛第一场
qq_41925919的博客
04-06 155
A - The Useless Toy CodeForces - 834A 大概题意 给你两个字符，和一个数字n，问你第一个字符转到第二个字符是顺时针转的还是逆时针转的或者无法判断，输入是合法的，保证第一个字符转n次一定可以转到第二个字符 字符只包括四钟，v , ^ , < , > 这个英文题。。。读到爆炸。。。。是个水题。。。就是读不出来题意。。你说气不气。。。。 直接模拟就行了。...
2018NYIST个人积分赛第四场 A - A POJ - 3026
qq_41071646的博客
04-01 214
//这个题打比赛的时候没看出来题意 后来猜出来题意 直接一发ac了 题目链接/// 哪里有错 还要多请告知点击打开链接这道题的就是最小生成树  然后 最难的一点就是建图 先把 a 和s 给 数字化 然后再二者的 关系  一步一步的 建图 最后来 松弛然后完成最小生成树 #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;cstr...
河工大校赛蹭赛记!
weixin_30610755的博客
04-24 77
河工大校赛邀请赛总结 还是让我理一理思路吧。 比赛12点开始，我们从学校去郑州至少4个小时，6点起床40集合然后7点准时出发，结果吃完早餐上车不一会晕的要死。11点半到达河工大，志愿者在门口等我们，然后直接带我们进去，表示想先去趟厕所，结果被带去听宣讲会，然后被告知午餐是面包和牛奶已经备好在桌子上。宣讲会完...
经典箴言和人生感悟
热门推荐
南阳理工学院CSDN高校俱乐部 的专栏
10-14 1万+
lihongmei0我的：收件箱资源博客空间设置|帮助|退出 首页 业界 移动 云计算 研发 论坛 博客 下载 更多 人的一生中只有七次机会，平均每七年拥有一次，大概在25岁到75岁，第一次通常抓不到，因为太年轻，最后一次也抓不到，因为太老。中途还有2次因为自己错过，所以抓不到。所以对于人来说人真正才会有三次机会，人的一生真正只有三次，只有称为能改变自己命运的机会才可以称作是机会。其
NYIST-linux应用开发实验指导书.doc
11-22
【NYIST-Linux应用开发实验指导书】 本实验指导书主要针对南阳理工学院软件学院软件工程教研室的学生，旨在提供Linux环境下应用开发的基础知识和实践技能。通过一系列实验，学生将掌握GCC编译器的使用、GDB调试器的...
NYIST-数据结构实验指导书.docx
07-12
数据结构是计算机科学中的核心课程，它探讨了如何有效地存储和处理数据，以便进行高效的计算。本实验指导书主要关注线性表、栈、队列和二叉树等基础数据结构的应用。 实验1关注线性表，这是一种基本的数据结构，...
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
2013年HDU专题：最短路径与背包问题训练
"HDU 专题分类（2013年8月）"是一场由webDIY和DIY组织的线上编程竞赛，针对ACM（Adaptive Computation and Machine Learning）问题提供了一系列的题目，旨在提升参赛者的算法设计和问题解决能力。这个专题训练涵盖了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值