二分常用技巧

最新推荐文章于 2022-09-13 11:08:47 发布
最新推荐文章于 2022-09-13 11:08:47 发布
阅读量112 收藏
点赞数
分类专栏： 挑战程序设计竞赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr___jie/article/details/88540404
版权

从小到大，升序排列

lower_bound(s,t,num):s-->t-1,查找到第一个大于或等于num的数的地址，不存在返回t

upper_bound(s,t,num):s-->t-1,查找到第一个大于num的数的地址，不存在返回t

从大到小，降序排列

lower_bound(s,t,num):s-->t-1,查找到第一个小于或等于num的数的地址，不存在返回t

upper_bound(s,t,num):s-->t-1,查找到第一个小于num的数的地址，不存在返回t

http://poj.org/problem?id=3061

求出总和不小于S的连续子序列的长度

普通方法

时间复杂度O(nlgn)

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
using namespace std;
int n,S;
int A[100010];
int sum[100010];///所有元素都大于0,所以是升序排列
void solve()
{
    for(int i=0; i<n; i++)
    {
        sum[i+1]=sum[i]+A[i];///sum[i]代表前i项的和
    }
    if(sum[n]<S)
    {
        printf("0\n");
        return;
    }
    int res=n;
    for(int s=0; sum[s]+S<=sum[n]; s++)//复杂度n,方法查找所有的(s,n]区间,直到区间和小于S
    {
        int t=lower_bound(sum+s,sum+n,sum[s]+S)-sum;//lgn
        res=min(res,t-s);
    }
    printf("%d\n",res);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(sum,0,sizeof(sum));
        scanf("%d%d",&n,&S);
        for(int i=0; i<n; i++)
            scanf("%d",&A[i]);
        solve();
    }
    return 0;
}

 

尺取法

更高效:  复杂度O(n)

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
using namespace std;
int n,S;
int A[100010];
void Scaling()
{
    int res=n+1;
    int s=0,t=0,sum=0;
    while(true)
    {
       while(t<n&&sum<S)//找到区间[s,t)大于或等于S
        sum+=A[t++];
       if(sum<S)break;//直到最后[s,n)的和小于S结束循环
       res=min(res,t-s);
       sum-=A[s++];//不断移动s,当区间[s,t)的和小于S时再往后移动t；
    }
    if(res>n)res=0;
    printf("%d\n",res);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&S);
        for(int i=0; i<n; i++)
            scanf("%d",&A[i]);
        Scaling();
    }
    return 0;
}

http://poj.org/problem?id=3320

阅读其中连续的一些页把所有的知识点全都覆盖到

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
#include<set>
#include<map>
using namespace std;
int n;
int a[1000010];
map<int,int>Count;
void Scaling()
{
    set<int>all;
    for(int i=0; i<n; i++)
    {
        all.insert(a[i]);
    }
    int nn=all.size();//返回set容器中元素的个数(重复的元素不计算)
    int res=n;
    int s=0,t=0,num=0;
    while(true)
    {
        while(t<n&&num<nn)
        {
            if(Count[a[t++]]++==0)//先执行if(Count[a[t]]==0),然后再执行Count[a[t]]++,最后执行t++
            {
                num++;
            }
        }
        if(num<nn)
            break;
        res=min(res,t-s);
        if(--Count[a[s++]]==0)//先执行--Count[a[t]],然后再执行if(Count[a[t]]==0),最后执行s++
        {
            num--;
        }
    }
    printf("%d\n",res);
}
int main()
{
     scanf("%d",&n);
     for(int i=0;i<n;i++)
     {
         scanf("%d",&a[i]);
         Count[a[i]]=0;
     }
     Scaling();
     return 0;
}

反转

http://poj.org/problem?id=3276

N头牛，F面向前方，B面向后方，有一个机器刚开始就必须设定一个数值K，每次操作可以使K头连续的牛转向

为了能让牛都面向前方，求最少的操作数M和对应最小的K；

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
using namespace std;
int n;
int dir[5010];//牛的方向:F:0,B:1;
int f[5010];//区间[i,i+k-1]是否翻转
//固定k，求最小操作数
//无解返回-1
int calc(int k)
{
    memset(f,0,sizeof(f));
    int res=0;
    int sum=0;//记录i前面k-1个数的操作和
    for(int i=0;i+k<=n;i++)
    {
      //计算区间[i,i-k+1];
      if((dir[i]+sum)%2!=0)
      {
          res++;
          f[i]=1;
      }
      sum+=f[i];//记录i前面k-1个数的操作和
      if(i-k+1>=0)//当记录f的值大于k个就要减去多余的
        sum-=f[i-k+1];
    }
    for(int i=n-k+1;i<n;i++)//最后k-1数不能进行翻转操作,,
    {
        if((dir[i]+sum)%2!=0)
            return -1;
        if(i-k+1>=0)
            sum-=f[i-k+1];
    }
    return res;
}
void solve()
{
    int K=1,M=n;
    for(int k=1;k<=n;k++)//遍历1-n;
    {
        int m=calc(k);
        if(m>=0&&M>m)
        {
            M=m;
            K=k;
        }
    }
    printf("%d %d\n",K,M);
}
int main()
{
    scanf("%d",&n);
    char a[5];
    for(int i=0;i<n;i++)
    {
        scanf("%s",a);
        dir[i]=(a[0]=='B');
    }
    solve();
    return 0;
}

http://poj.org/problem?id=3279

有一个M*N的格子有正反两面一面是白色0，一面是黑色1，牛每次翻转一个格子，这个格子相邻的上下左右的格子都会翻转，要求牛将M*N个格子都翻成白色，求出用最小步数完成时每个格子的翻转的次数。最小步数有多个解时，输出字典序最小的一组，不存在的话输出IMPOSSIBLE；

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
using namespace std;
//邻接格子的坐标
const int dx[5]={-1,0,0,0,1};
const int dy[5]={0,-1,0,1,0};
//输入
int N,M;
int tile[20][20];

int opt[20][20];//保存最优解
int flip[20][20];//记录是否翻转
//查询(x,y)的颜色
int get(int x,int y)
{
    int c=tile[x][y];
    for(int i=0;i<5;i++)
    {
        int x2=x+dx[i],y2=y+dy[i];
        if(0<=x2&&x2<M&&0<=y2&&y2<N)
            c+=flip[x2][y2];
    }
    return c%2;
}
//求出第一行确定情况下的最小操作次数
//不存在返回-1
int calc()
{
    for(int i=1;i<M;i++)
    {
        for(int j=0;j<N;j++)
        {
            if(get(i-1,j)!=0)//如果(i-1,j)是黑色的话，这个地方必须翻转
                flip[i][j]=1;
        }
    }
    //判断最后一行是否全白
    for(int j=0;j<N;j++)
    {
        if(get(M-1,j)!=0)
            return -1;
    }
    //统计
    int res=0;
    for(int i=0;i<M;i++)
        for(int j=0;j<N;j++)
        res+=flip[i][j];
    return res;
}

void solve()
{
    int res=-1;
    //按照字典序遍历第一行所有的可能性---0,001,01,11,字典序---
    for(int i=0;i<1<<N;i++)
    {
        memset(flip,0,sizeof(flip));
        for(int j=0;j<N;j++)
            flip[0][N-j-1]=i>>j&1;
        int num=calc();
        if(num>=0&&(res<0||res>num))
        {
            res=num;
            memcpy(opt,flip,sizeof(flip));//储存最优解,将flip中的元素拷贝到opt中
        }
    }
    if(res<0)//无解
        printf("IMPOSSIBLE\n");
    else
    {
        for(int i=0;i<M;i++)
        {
            for(int j=0;j<N;j++)
            {
                printf("%d%c",opt[i][j],j+1==N?'\n':' ');
            }
        }
    }
}
int main()
{
    scanf("%d%d",&M,&N);
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<N;j++)
        {
            scanf("%d",&tile[i][j]);
        }
    }
    solve();
    return 0;
}

弹性碰撞

http://poj.org/problem?id=3684

用N个半径为Rcm的球做实验在H米高的位置放了一个圆筒，实验开始最下面的球开始掉落，此后每一秒又有一个球掉落(不计空气阻力，所有的碰撞都是弹性碰撞)，求实验开始的T秒中每个球底端的高度，(g==10.0m/s^2)

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
using namespace std;
const double g=10.0;
int N,H,R,T;
double y[110];//球的最终位置
double calc(int T)
{
    if(T<0)return H;
    double t=sqrt(2*H/g);
    int k=(int)T/t;
    if(k%2==0)//k为偶数
    {
        double d=T-k*t;
        return H-g*d*d/2.0;
    }
    else//k为奇数
    {
        double d=k*t+t-T;
        return H-g*d*d/2.0;
    }
}
void solve()
{
    for(int i=0;i<N;i++)
    {
        y[i]=calc(T-i);
    }
    sort(y,y+N);//假设球可以从球中间穿过去,彼此间相互不影响,求出y值,进行排序--最下面的球肯定最低(因为球是穿不过去的)---
    for(int i=0;i<N;i++)
    {
        printf("%.2lf%c",y[i]+2*R*i/100.0,i+1==N?'\n':' ');//第i个球的高度再加上2*R*i
    }
}
int main()
{
    int C;
    scanf("%d",&C);
    while(C--)
    {
       scanf("%d%d%d%d",&N,&H,&R,&T);
       solve();
    }
    return 0;
}

   折半枚举

给定各有n个整数的四个序列,A,B,C,D.要从每个序列中个取出一个数,使四个数的和为0.求出这样的组合个数.当一个数列中有多个相同的数字时，把它们作为不同的数字来看(1<=n<4000,|数字的值|<=2^28)

//如果暴力，时间为O(n^4)
//c+d=-a-b,将C,D中取数字的n^2中方法枚举出来,将这些和排好序,再用二分搜索,时间复杂度O(nlgn)
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
using namespace std;
const int MAX_N=4010;
int n;
int A[MAX_N],B[MAX_N],C[MAX_N],D[MAX_N];
int CD[MAX_N*MAX_N];

void solve()
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            CD[i*n+j]=C[i]+D[j];
        }
    }
    sort(CD,CD+n*n);

    long long res=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            int cd=-(A[i]+B[j]);
            //取出C和D中和为cd的部分
            res+=upper_bound(CD,CD+n*n,cd)-lower_bound(CD,CD+n*n,cd);
        }
    }
    printf("%lld\n",res);
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d%d%d%d",&A[i],&B[i],&C[i],&D[i]);
    }
    solve();
    return 0;
}

 超大背包问题(折半枚举)

有重量和价值分别为wi,vi的n个物品.从这些物品中挑选总重量不超过W的物品，求所有挑选方案中价值总和的最大值(1<=n<=40,1<=wi,vi<=10^15,1<=W<=10^15)

 

//因为价值和重量都很大,相比之下n比较小，但挑选物品的方法有2^n种不能直接枚举，但是把它拆成两半后再枚举的话,每部分只有20个是可行的
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
#include<string>
#include<vector>
#include<utility>
typedef long long ll;
using namespace std;
const int MAX_N=50;
const ll INF=1e18;
//输入
int n;
ll w[MAX_N],v[MAX_N];
ll W;

pair <ll,ll> ps[1<<MAX_N/2];//重量，价值;pair内设的是什么变量，里面就要写什么变量否则就会报错

void solve()
{
    //枚举前半部分
    int n2=n/2;
    for(int i=0;i<1<<n2;i++)
    {
        ll sw=0,sv=0;
        for(int j=0;j<n2;j++)
        {
            if(i>>j&1)
            {
                sw+=w[j];
                sv+=v[j];
            }
        }
        ps[i]=make_pair(sw,sv);
    }
    //去除多余元素,使重量和价值都从小到大排列
    sort(ps,ps+(1<<n2));//w重量按从小到大排列，若重量相等则v价值小的放前
    int m=1;
    for(int i=1;i<1<<n2;i++)
    {
        if(ps[m-1].second<ps[i].second)
            ps[m++]=ps[i];
    }
    //枚举后半部分并求解
    ll res=0;
    for(int i=0;i<1<<(n-n2);i++)
    {
        ll sw=0,sv=0;
        for(int j=0;j<n-n2;j++)
        {
            if(i>>j&1)
            {
                sw+=w[n2+j];
                sv+=v[n2+j];
            }
        }
        if(sw<=W)
        {
            ll tv=(lower_bound(ps,ps+m,make_pair(W-sw,INF))-1)->second;//找到重量相等,价值相等的话就会返回这个地址,否则就会返回第一个大于重量的地址
            res=max(res,sv+tv);
        }
    }
    printf("%lld\n",res);
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld%lld",&w[i],&v[i]);
    }
    scanf("%lld",&W);
    solve();
}

       坐标离散化

w*h的格子上画了n条垂直或水平的宽度为1的直线，求出这些线将格子划分成了多少个区域(x是列,y是行)

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include <time.h>
#include<math.h>
#include<string>
#include<vector>
#include<utility>
using namespace std;
const int maxn=510;
const int dx[4]={0,0,1,-1};
const int dy[4]={-1,1,0,0};
//输入
int W,H,N;
int X1[maxn],X2[maxn],Y1[maxn],Y2[maxn];
//标记
bool fld[maxn*6][maxn*6];
//对x1,x2进行坐标离散化，并返回离散化之后的宽度
int compress(int *X1,int *X2,int w)
{
    vector<int> xs;

    for(int i=0; i<N; i++)
    {
        for(int d=-1; d<=1; d++)//保留x1,x2和他们两侧的坐标
        {
            int tx1=X1[i]+d,tx2=X2[i]+d;
            if(1<=tx1&&tx1<=W)
                xs.push_back(tx1);
            if(1<=tx2&&tx2<=W)
                xs.push_back(tx2);
        }
    }
    sort(xs.begin(),xs.end());
    //去重
    xs.erase(unique(xs.begin(),xs.end()),xs.end());/*unique去除相邻的重复元素，只保
    留一个但并不是将重复原素删除，而是将它们移到了后面，返回的迭代器指向超出无重复元素范围末端的下一个位置*/
    //将x1,x2化为离散化后的坐标
    for(int i=0; i<N; i++)
    {
        X1[i]=find(xs.begin(),xs.end(),X1[i])-xs.begin();
        X2[i]=find(xs.begin(),xs.end(),X2[i])-xs.begin();
    }
    return xs.size();//离散化后的宽度
}

void solve()
{
    //坐标离散化
    W=compress(X1,X2,W);
    H=compress(Y1,Y2,H);
    //标记有直线的部分
    memset(fld,0,sizeof(fld));
    for(int i=0;i<N;i++)
    {
        for(int y=Y1[i];y<=Y2[i];y++)
        {
            for(int x=X1[i];x<=X2[i];x++)
            {
                fld[y][x]=true;
            }
        }
    }
    //求区间个数
    int ans=0;
    for(int y=0;y<H;y++)
    {
        for(int x=0;x<W;x++)
        {

            if(fld[y][x])continue;
            ans++;
            //宽度优先搜索
            queue<pair<int,int> >que;
            que.push(make_pair(x,y));
            while(!que.empty())
            {
                int sx=que.front().first,sy=que.front().second;
                que.pop();

                for(int i=0;i<4;i++)
                {
                    int tx=sx+dx[i],ty=sy+dy[i];
                    if(tx<0||tx>=W||ty<0||ty>=H)
                        continue;
                    if(fld[ty][tx])continue;
                    que.push(make_pair(tx,ty));
                    fld[ty][tx]=true;
                }
            }
        }
    }
    printf("%d\n",ans);
}
int main()
{
    scanf("%d%d%d",&W,&H,&N);
    for(int i=0;i<N;i++)
    {
        scanf("%d%d%d%d",&X1[i],&X2[i],&Y1[i],&Y2[i]);
    }
    solve();
}
//10 10 5
//1 6 4 4
//1 10 8 8
//4 4 1 10
//9 9 1 5
//10 10 6 10

 

                                                       

                  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

                  

 

 

 

 

 

 

 

 

 

  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

ZZZ19880423
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#编程经验技巧宝典
06-01
100 <br>0158　如何将二进制数转换为十六进制数　100 <br>0159　如何实现0～9之间随机整数　101 <br>0160　如何实现0～1之间随机数　101 <br>0161　如何返回数字的绝对值　101 <br>5.2　控件数据处理...
javascript常用对象梳理
06-23
JS中的常用对象[转载]web 技术 2010-06-05 15:00:30 阅读3 评论0 字号：大中小 订阅 [removed] Window For JavaScript 熟练window对象的open、close、alert、confirm、prompt、setTimeout、clearTimeout、...
二分查找算法的原理及一个实用小技巧
Veaxen的博客
05-28 5821
二分查找算法是在有序数组中用到的较为频繁的一种算法，在未接触二分查找算法时，最通用的一种做法是，对数组进行遍历，跟每个元素进行比较，其时间复杂度为O(n)，但二分查找算法则更优，因为其查找时间复杂度为O(log2 n)，比如数组{0,1,2,3,4,5,6,7,8 9}，查找元素6，用二分查找的算法执行的话，其顺序为：     1.第一步查找中间元素，即4，由于4     2.寻找{5,6,7
二分写法总结
lin的博客
07-13 3150
二分求下界 所谓下界，指的是在一段区间[l, r]中，找出符合要求的一个数x，使得[l, x)这段区间都不符合要求，而[x, r]都符合要求 int lower_bound(int* a, int l, int r) { int mid, ans = -1; while(l &amp;lt;= r) { mid = (l + r) / 2; if(c...
二分查找法+左右边界搜索
IMUHERO
08-31 3819
思路 我相信对很多读者朋友来说，编写二分查找的算法代码属于玄学编程，虽然看起来很简单，就是会出错，要么会漏个等号，要么少加个 1。 不要气馁，因为二分查找其实并不简单。看看 Knuth 大佬（发明 KMP 算法的那位）怎么说的： Although the basic idea of binary search is comparatively straightforward, the d...
常用技巧 —— 离散化
Alex_McAvoy的博客
03-06 1716
【概述】 离散化是数据结构中的一个常用技巧，其可以有效的降低时空复杂度，其基本思想就是在众多可能的情况中，只去考虑需要用到的值，通过离散化，可以改进低效的算法，甚至实现根本不可能实现的算法。 对于一些数量较少，但数值较大或者可能出现负数这种难以处理的数据，自身无法作为数组的下标保存对应的属性，如果这时只是需要这些数据的相对属性， 那么可以对其进行重新赋值，即进行离散化处理。 简单来说，对于 ...
【精华】excel办公常用小技巧
weixin_43917532的博客
09-13 2万+
1.excel一键下拉到一列的最后一个内容 ctrl+shift+↓，同理，向上可以上下左右如此选择； 同理可以进行多行操作； 2.选中某列中的多格 如果要选中某一列中的连续多格，先选中最顶部的一格，按下shift键，鼠标选中最底部一格； 同理可以进行多行操作 3.选中某一列后批量复制（或复制公式格式）：ctrl+D； 4.合并多列单元格内容：在新格中输入公式：=b1&c1&d1等等 5.在excel里可用公式=(TODAYQ-A2)/365来计算出年龄。 6.计算平均年龄：单元格输入公式【
VScode编程软件常用技巧
Hello，陌生人^o^。遇见你真好...
06-23 1万+
由于经常使用这个编程软件，之前使用一些功能老是过段时间就忘记，只记住一些基本的操作。俗话说：工欲善其事，必先利其器。所以打算整理一下，以便忘记的时候可以温习一下，不至于浪费编码时间。 Visual Studio Code 是一个运行在桌面上，多平台的轻量级且功能强大的源代码编辑器。内置有JavaScript的，TypeScript和Node.js的支持，其他语言如C ++，C＃，Python和P...
Hivesql常用优化技巧
weixin_56175042的博客
11-05 6631
首先介绍下什么是HIve？ 1.基于Hadoop的开源的数据仓库工具，用于处理海量海量结构化数据。 2.Hive把HDFS中的结构化的数据文件映射成数据表。 3.Hive通过HiveSQL进行解析和转换，最终映射成一系列在hadoop上运行的mapreduce任务，通过执行这些任务完成分析和处理。 4.HiveSql和Mysql一样，都遵循着SQL的标准，因此它们很多语句都是一样的。 一、先复习下SQL的语句的结构 SELECT * （必须） FROM 表（数据源） WHERE
LaTeX详细教程+技巧总结
热门推荐
NSJim的博客
11-29 18万+
LaTeX技巧总结，包含LaTeX工具，LaTeX模板，LaTeX技巧，LaTeX基础，文章架构，字体、大小和颜色，链接，列表，图片，表格，数学公式，算法（伪代码），代码块，论文写作，等等。
常用的文档编辑技巧
晴天下的大头娃娃
04-06 2180
在此，对常用的一些文件编辑中的方法进行总结，以后方便查询(*^▽^*) Word篇 1、图片嵌入 2、插入表名-图名 （表在表上，图在图下） 3、表头分页显示 4、插入表连续增加行数 先增加一行，然后按F4可以连续插入行 5、设置页面颜色 PPT篇 Excel篇 1、不/允许跨页断行 2、单元格居中 3、表格递增 先填好前几个，然后全选中向下拉 4、删选 选中数据区域，然后右键，选择设置单元格格式。 在“自定义......
二进制运算技巧
chengfree的博客
07-05 2303
二进制运算常用技巧 1、 用于整数的奇偶性判断 一个整数a, a & 1 这个表达式可以用来判断a的奇偶性。二进制的末位为0表示偶数，最末位为1表示奇数。若a为奇数，则a & 1 的结果等于1。 2、 判断n是否是2的正整数冪 (!(n&(n-1)) ) && n 好！看完上面的两个小例子，相信大家都有一个感性的认识。从理论上讲，如果一个数a他是2的正整数幂...
ACM竞赛中的技巧分享
05-18
常用算法：排序和搜索算法（如快速排序、二分查找）、图算法（如Dijkstra、Floyd-Warshall、Kruskal、Prim）、动态规划、贪心算法、回溯、分治、字符串处理算法（如KMP、Trie）。 数据结构：数组、链表、栈、队列、...
ECSHOP设置及开发技巧汇总
11-22
3.1 模板组常用SQL语句 76 3.2 商品详情页面属性价格显示其对应价格 76 3.3 设置ECSHOP支持货到付款 79 3.4 商品列表页判断商品是新品、精品、还是热销 80 3.5 如何把后台模板备份功能去掉 82 3.6 模板有的文章内容...
word使用技巧大全
03-18
98 其他常用技巧 98 99、Word中查找/替换通配符和代码 101 四十三、Word中公式编辑器的使用技巧 104 1、公式编辑器的启动与退出 104 四十四、Word文档设置多个不同的页眉页脚 107 四十五、Word 快捷键 108 四十六、...
Java开发案例-springboot-66-自定义starter-源代码+文档.rar
05-31
Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar
单家独院式别墅图纸D027-三层-12.80&10.50米-施工图.dwg
05-31
单家独院式别墅图纸D027-三层-12.80&10.50米-施工图.dwg
啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦
最新发布
05-31
啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦
课程大作业基于Vue+PHP开发的简单问卷系统源码+使用说明.zip
05-31
【优质项目推荐】 1、项目代码均经过严格本地测试，运行OK，确保功能稳定后才上传平台。可放心下载并立即投入使用，若遇到任何使用问题，随时欢迎私信反馈与沟通，博主会第一时间回复。 2、项目适用于计算机相关专业（如计科、信息安全、数据科学、人工智能、通信、物联网、自动化、电子信息等）的在校学生、专业教师，或企业员工，小白入门等都适用。 3、该项目不仅具有很高的学习借鉴价值，对于初学者来说，也是入门进阶的绝佳选择；当然也可以直接用于 毕设、课设、期末大作业或项目初期立项演示等。 3、开放创新：如果您有一定基础，且热爱探索钻研，可以在此代码基础上二次开发，进行修改、扩展，创造出属于自己的独特应用。 欢迎下载使用优质资源！欢迎借鉴使用，并欢迎学习交流，共同探索编程的无穷魅力！ 课程大作业基于Vue+PHP开发的简单问卷系统源码+使用说明.zip Project setup ``` npm install ``` ### Compiles and hot-reloads for development ``` npm run serve ``` ### Compiles and minifies for production ``` npm run build ``` ### Lints and fixes files ``` npm run lint ``` ### Customize configuration See [Configuration Reference](https://cli.vuejs.org/config/).
小黑计算机二级python题库判0分
07-23
为了避免小黑计算机二级python题库判0分，考生应该提前准备好相关的知识和技巧，了解python的基本语法和常用库函数的使用方法。在做题时，要仔细阅读题目的要求，理解题目意思并正确理解解题思路。要注重细节，特别...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值