BUPT 2014新生暑假个人排位赛05

最新推荐文章于 2019-04-20 14:46:01 发布
最新推荐文章于 2019-04-20 14:46:01 发布
阅读量768 收藏 1
点赞数
分类专栏： 数学 & 博弈论 & FFT & 位运算 动态规划 & 贪心 模拟 & 匹配 文章标签： bupt ACM math
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/38072259
版权

BOJ 442 平方的平均值


注意看题啊，用long long和绝对值是必须的啊！
另外，不要我证明为什么取一元子集就一定是对的！ 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
 
using namespace std;
 
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
 
//-----------------------------------------------------------------------
 
const int MAXN=100010;
int a[MAXN];
 
int main()
{
    int n;
    while(read(n))
    {
        long long minn=MAXN+10;
        for(int i=0;i<n;i++)
        {
            long long temp;
            scanf("%lld",&temp);
            if(fabs(temp)<minn)
                minn=fabs(temp);
        }
        printf("%lld\n",minn*minn);
    }
    return 0;
}

BOJ 431 立方体

根据空间向量来计算，设缺失的点关于体心的对称点为A，则A满足：到其他六个点的向量的长度三个三个相同，可以按照升序排序，则前三个相同，后三个相同。那么，缺失的点为A点加上前三个长度形同的向量。 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define EPS 1e-10
 
using namespace std;
 
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
 
//-----------------------------------------------------------------------
 
typedef long long ll;
 
inline ll sqr(ll a)
{
    return a*a;
}
 
int dcmp(double k)
{
    if(k>=EPS||k<=-EPS)
        return 1;
    return 0;
}
 
struct Node
{
    ll x,y,z;
    Node(){};
    Node(ll x,ll y,ll z):x(x),y(y),z(z){}
    double length() const
    {
        return sqrt(sqr(x)+sqr(y)+sqr(z));
    }
}a[10],c[120],ans;
 
Node operator - (const Node &a,const Node &b)
{
    return Node(a.x-b.x,a.y-b.y,a.z-b.z);
}
 
Node operator + (const Node &a,const Node &b)
{
    return Node(a.x+b.x,a.y+b.y,a.z+b.z);
}
 
double Dot(const Node &a,const Node &b)
{
    return a.x*b.x+a.y*b.y+a.z*b.z;
}
 
bool cmp(Node a,Node b)
{
    return a.length()<b.length();
}
 
int main()
{
    int T;
    read(T);
    while(T--)
    {
        for(int i=0;i<7;i++)
            read(a[i].x),read(a[i].y),read(a[i].z);
        for(int i=0;i<7;i++)
        {
            int tot=0;
            for(int j=0;j<7;j++)
            {
                if(i==j)
                    continue;
                c[tot++]=a[j]-a[i];
            }
            sort(c,c+tot,cmp);
//            for(int i=0;i<6;i++)
//                cout<<" "<<c[i].length()<<":"<<c[i].x<<" "<<c[i].y<<" "<<c[i].z<<" "<<endl;
            if(!dcmp(c[0].length()-c[1].length())&&!dcmp(c[0].length()-c[2].length())&&!dcmp(c[3].length()-c[4].length())&&!dcmp(c[3].length()-c[5].length()))
            {
                ans=a[i]+c[0]+c[1]+c[2];break;
            }
        }
        printf("%lld %lld %lld\n",ans.x,ans.y,ans.z);
    }
    return 0;
}
/*
1
0 0 0
0 0 1000000
0 1000000 0
0 1000000 1000000
1000000 0 0
1000000 0 1000000
1000000 1000000 0
*/


BOJ 432 字符串重排

贪心，如果有字母的个数  num ，字符串长度 len，已填充的字符串个数 i 满足：2 * num - len + i == 1 的情况，则填充改字母；如果没有上述情况，则填充字典序最小的那个字母。以上所有点都满足不等于上一个的情况。
最后，其实这个应该放在最上面： 如果某个字母的个数  2 * num - len >=2，则不可能重排。 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define INF 0x3f3f3f3f
 
using namespace std;
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-----------------------------------
char ch;
int  ans[100010];
 
int main()
{
    int T;
    read(T);
    while(T--)
    {
        int num[30]={0},len=0,maxx=-INF;
        while((ch=getchar())!='\n')
            num[ch-'a']++,len++;
        for(int i=0;i<26;i++)
            if(num[i]>maxx)
                maxx=num[i];
        if(2*maxx-len>1)
        {
            puts("-1");continue;
        }
        int last=-1;
        for(int i=0;i<len;i++)
        {
            int po;
            bool flag=false;
            for(int j=0;j<26;j++)
                if(j!=last&&num[j]*2-len+i==1)
                {
                    po=j;flag=true;break;
                }  
            for(int j=0;j<26&&!flag;j++)
                if(num[j]&&j!=last)
                {
                    po=j;break;
                }
            ans[i]=last=po;
            num[po]--;
        }
        for(int i=0;i<len;i++)
            putchar((char)ans[i]+'a');
        putchar('\n');
    }
    return 0;
}


BOJ 433 Fibnacci

所有类似的递推式都可以通过前后的消元，将 n （或者某个数列 A n）这个消除，从而达到满足常系数的递推式。
题目的通项是

F[ n ] = Fibonacci + Lucas - n - 3，这个没什么用，你们看看就好.....
实际有用的而是

F [ n ] = 3 * F [ n-1 ] - 2 * F [ n-2 ] - F [ n-3 ] + F [ n-4 ];
然后大家就可以用矩阵快速幂轻松搞定。 


#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define EPS 1e-10
#define INF 0x3f3f3f3f
 
using namespace std;
 
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
 
//-----------------------------------------------------------------------
 
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
 
 
const int M=1000000007;
 
mat mul(mat &A,mat &B)
{
    mat c(A.size(),vec(B[0].size()));
    for(int i=0;i<A.size();i++)
        for(int k=0;k<B.size();k++)
            for(int j=0;j<B[0].size();j++)
                c[i][j]=(c[i][j]+((A[i][k]+M)%M)*((B[k][j]+M))%M)%M;
    return c;
}
mat qpow(mat a,ll n)
{
    mat b(a.size(),vec(a.size()));
    for(int i=0;i<a.size();i++)
        b[i][i]=1LL;
    while(n>0)
    {
        if(n&1)
            b=mul(b,a);
        a=mul(a,a);
        n>>=1;
    }
    return b;
}
void solve(ll n)
{
    mat A(4,vec(4));
    mat B(4,vec(1));
    A[0][0]=3;A[0][1]=-2;A[0][2]=-1;A[0][3]=1;
    A[1][0]=1;A[2][1]=1;A[3][2]=1;
    B[0][0]=8;B[1][0]=4;B[2][0]=1;B[3][0]=1;
    A = qpow(A,n);
    B = mul(A,B);
    printf("%lld\n",B[0][0]);
}
 
int main()
{
    ll n,T;
    read(T);
    while(T--)
    {
        read(n);
        if(n==0)
            printf("1\n");
        else if(n==1)
            printf("1\n");
        else if(n==2)
            printf("4\n");
        else if(n==3)
            printf("8\n");
        else
            solve(n-3LL);
    }
    return 0;
}

BOJ 441 机智的学姐

纯模拟题，细心大胆持之以恒！ 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
struct node
{
    int sg[16];
    int cp[14];
    int tr[14][3];     //三不带 三带一 三带二
    int ss[13][9];    //单顺  12张牌   最多8个起始点
    int bs[11][11];    //双顺  最多10对  最多10个起始点
    int ts[7][12][3];    //三顺  最多6组   最多11个起始点   不带 带单 带双
    int bomb[14][3];   //炸 13种 不带就是炸 带单*2 带双*2
}A,B,T;
char a[50],b[50];
void Pre_Work(node &x,char y[])
{
    int i,j,k,len=strlen(y);
    memset(&x,0,sizeof(x));
    //cout<<y<<endl;
    for(i=0;i<len;i++)   //处理单张牌
    {
        int t;
        if(y[i]>='3'&&y[i]<='9')t=y[i]-'2';
        else if(y[i]=='T')t=8;
        else if(y[i]=='J')t=9;
        else if(y[i]=='Q')t=10;
        else if(y[i]=='K')t=11;
        else if(y[i]=='A')t=12;
        else if(y[i]=='2')t=13;
        else if(y[i]=='X')t=14;
        else if(y[i]=='Y')t=15;
        x.sg[t]++;
        if(x.sg[0]<t)x.sg[0]=t;
    }
    for(i=1;i<=13;i++)     //处理对子 以及三不带 和炸弹
    {
        if(x.sg[i]>1)
        {
            x.cp[i]=1;
            x.cp[0]=i;
        }
        if(x.sg[i]>2)
        {
            x.tr[i][0]=1;
            x.tr[0][0]=i;
        }
        if(x.sg[i]>3)
        {
            x.bomb[i][0]=1;
            x.bomb[0][0]=i;
        }
    }
    for(i=1;i<=13;i++)    //处理三带一 三带二
    {
        if(x.tr[i][0]==0)continue;
        for(j=1;j<=15;j++)
        {
            if(j==i)continue;
            if(x.sg[j])
            {
                x.tr[i][1]=1;
                x.tr[0][1]=i;
                break;
            }
        }
        for(j=1;j<=13;j++)
        {
            if(j==i)continue;
            if(x.cp[j])
            {
                x.tr[i][2]=1;
                x.tr[0][2]=i;
                break;
            }
        }
    }
    for(i=1;i<=13;i++)    //处理四带二 四带两对
    {
        if(x.tr[i][0]==0)continue;
        int cnt=0;
        for(j=1;j<=15;j++)
        {
            if(j==i)continue;
            if(x.sg[j])cnt+=x.sg[j];
            if(cnt>=2)
            {
                x.bomb[i][1]=1;
                x.bomb[0][1]=i;
                break;
            }
        }
        cnt=0;
        for(j=1;j<=13;j++)
        {
            if(j==i)continue;
            if(x.cp[j])cnt++;
            if(cnt==2)
            {
                x.bomb[i][2]=1;
                x.bomb[0][2]=i;
                break;
            }
        }
    }
    for(i=1;i<=8;i++)   //小五张
        if(x.sg[i]&&x.sg[i+1]&&x.sg[i+2]&&x.sg[i+3]&&x.sg[i+4])
        {
            x.ss[5][i]=1;
            x.ss[5][0]=i;
        }
    for(i=6;i<=12;i++)  //大于五张
        for(j=1;i+j-1<=12;j++)
            if(x.ss[i-1][j]&&x.sg[i+j-1])
            {
                x.ss[i][j]=1;
                x.ss[i][0]=j;
            }
    for(i=1;i<=10;i++)   //三对
        if(x.cp[i]&&x.cp[i+1]&&x.cp[i+2])
        {
            x.bs[3][i]=1;
            x.bs[3][0]=i;
        }
    for(i=4;i<=12;i++)  //大于三对
        for(j=1;i+j-1<=12;j++)
            if(x.bs[i-1][j]&&x.cp[i+j-1])
            {
                x.bs[i][j]=1;
                x.bs[i][0]=j;
            }
    for(i=1;i<=11;i++)   //两个三组
        if(x.tr[i][0]&&x.tr[i+1][0])
        {
            x.ts[2][i][0]=1;
            x.ts[2][0][0]=i;
        }
    for(i=3;i<=6;i++)  //大于两个三组
        for(j=1;i+j-1<=12;j++)
            if(x.ts[i-1][j][0]&&x.tr[i+j-1][0])
            {
                x.ts[i][j][0]=1;
                x.ts[i][0][0]=j;
            }
    //system("pause");
    for(i=2;i<=6;i++)   //飞机
    {
        for(j=1;i+j-1<=12;j++)
        {
            if(x.ts[i][j][0]==0)continue;
            int cnt=0;
            for(k=1;k<=15;j++)
            {
                if(k>=j&&k<=i+j-1)continue;
                if(x.sg[j])cnt+=x.sg[j];
                if(cnt>=i)
                {
                    x.ts[i][j][1]=1;
                    x.ts[i][0][1]=j;
                    break;
                }
            }
            cnt=0;
            for(k=1;k<=13;k++)
            {
                if(k>=j&&k<=i+j-1)continue;
                if(x.cp[j])cnt++;
                if(cnt==i)
                {
                    x.ts[i][j][2]=1;
                    x.ts[i][0][2]=j;
                    break;
                }
            }
        }
    }
}
void Solve()
{
    while(scanf("%s%s",a,b)!=EOF)
    {
        A=T;
        B=T;
        Pre_Work(A,a);
        //cout<<"Awan\n";
        Pre_Work(B,b);
        //cout<<"Bwan\n";
        if(A.sg[14]&&A.sg[15])
        {
            printf("Yes\n");
            //cout<<1<<endl;
            continue;
        }
        else if(B.sg[14]&&B.sg[15])
        {
            printf("No\n");
            //cout<<2<<endl;
            continue;
        }
        if(A.bomb[0][0]>=B.bomb[0][0]&&A.bomb[0][0]>0)
        {
            printf("Yes\n");
            //cout<<3<<endl;
            continue;
        }
        if(A.bomb[0][0]<B.bomb[0][0])
        {
            printf("No\n");
            //cout<<4<<endl;
            continue;
        }
        if((A.sg[0]>=B.sg[0]&&A.sg[0])||(A.cp[0]>=B.cp[0]&&A.cp[0])||(A.tr[0][0]>=B.tr[0][0]&&A.tr[0][0])||(A.tr[0][1]>=B.tr[0][1]&&A.tr[0][1])||(A.tr[0][2]>=B.tr[0][2]&&A.tr[0][2]))
        {
            printf("Yes\n");
            //cout<<5<<endl;
            continue;
        }
        int flag=0;
        for(int i=5;i<=12;i++)
            if(A.ss[i][0]>=B.ss[i][0]&&A.ss[i][0])
            {
                flag=1;
                break;
            }
        for(int i=3;i<=10;i++)
            if(A.bs[i][0]>=B.bs[i][0]&&A.bs[i][0])
            {
                flag=1;
                break;
            }
        for(int i=2;i<=6;i++)
            if((A.ts[i][0][0]>=B.ts[i][0][0]&&A.ts[i][0][0])||(A.ts[i][0][1]>=B.ts[i][0][1]&&A.ts[i][0][1])||(A.ts[i][0][2]>=B.ts[i][0][2]&&A.ts[i][0][2]))
            {
                flag=1;
                break;
            }
        if(flag==1)
        {
            printf("Yes\n");
            //cout<<6<<endl;
            continue;
        }
        else
        {
            printf("No\n");
            //cout<<7<<endl;
            /*
        cout<<A.bs[3][0]<<endl;
        cout<<B.bs[3][0]<<endl;
        cout<<A.bs[4][0]<<endl;
        cout<<B.bs[4][0]<<endl;
        cout<<A.bs[5][0]<<endl;
        cout<<B.bs[5][0]<<endl;*/
            continue;
        }
        //cout<<B.bs[3][0]<<endl;
        /*
        A=B;
        printf("sg_max=%d\n",A.sg[0]);
        printf("cp_max=%d\n",A.cp[0]);
        printf("tr[0]_max=%d\n",A.tr[0][0]);
        printf("tr[1]_max=%d\n",A.tr[0][1]);
        printf("tr[2]_max=%d\n",A.tr[0][2]);
        for(int i=5;i<=12;i++)
            printf("ss[%d]_max=%d\n",i,A.ss[i][0]);
        for(int i=3;i<=10;i++)
            printf("bs[%d]_max=%d\n",i,A.bs[i][0]);
        for(int i=2;i<=6;i++)
        {
            printf("ts[%d][0]_max=%d\n",i,A.ts[i][0][0]);
            printf("ts[%d][1]_max=%d\n",i,A.ts[i][0][1]);
            printf("ts[%d][2]_max=%d\n",i,A.ts[i][0][2]);
        }
        printf("bomb[0]_max=%d\n",A.bomb[0][0]);
        printf("bomb[1]_max=%d\n",A.bomb[0][1]);
        printf("bomb[2]_max=%d\n",A.bomb[0][2]);
        */
          
    }
}
int main()
{
    Solve();
   // system("pause");
    return 0;
}




SuPhoebe
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bupt 13级新生专题训练① String1
08-03
本题“Bupt 13级新生专题训练① String1”涉及到的关键知识点是回文判断，其中包括两种类型的回文：普通回文和镜像回文。 1. **普通回文**：一个字符串如果正读和反读是一样的，那么它就是一个普通回文。例如，...
BOJ 433. Fibnacci
leodestiny
07-25 646
思路：f(0) = f(1) = 1, f(n) = f(n-1) + f(n-2) + n,.对于给定的n，求出f(n)
kari433 矩阵快速幂
smilewsw的专栏
08-06 522
433. Fibnacci 时间限制 1000 ms 内存限制 65536 KB 题目描述 已知函数f,f(0)=f(1)=1,对于所有n>=2，f(n)=f(n-1)+f(n-2)+n。给定n，求f(n)。 输入格式 第一行一个整数t,表示组数,t 输出格式 对于每组测试组，输出一行f(n)%1000000007. 输入
BOJ 448. 游戏
leodestiny
08-02 406
题意：给出一个多边形，放在一个
字符串全排列算法
热门推荐
小一的专栏
05-17 2万+
前言 字符串的排列组合问题，困扰了我好久，递归的思想我今天一定要掌握，擦，话不多说，博客走起！ 问题 输入一个字符串，打印出该字符串中字符的所有排列。例如输入字符串abc，则输出由字符a，b，c所能排列出来的所有字符串abc，acb，bac，bca，cab和cba 思路 这是典型的递归求解问题，递归算法有四个特性： 必须有可达到的终止条件，否则程序陷入死循环子问
字符串重排
bruce_zhen的博客
04-20 3109
void parseString(char* str){ int i,digitCount=0,alphaCount=0; int index1=0,index2=0,index3=0; char temp[strlen(str)]; for (i = 0; str[i]!='\0'; ++i) { if (isdigit(str[i])) ...
BUPT NoSQL数据库
03-31
本章节主要探讨了NoSQL数据库中的三种重要类型：图数据库、文档数据库和列族数据库，并结合北京邮电大学（BUPT）的相关课程作业进行深入学习。 首先，让我们详细了解一下图数据库。图数据库以节点、边和属性三元组...
BUPT软件工程分布式温控系统
11-07
在本项目“BUPT软件工程分布式温控系统”中，我们看到了一个基于Python编程语言实现的系统，结合了PyQT5图形用户界面库和MySQL数据库技术。 1. **Python编程**：Python是一种高级编程语言，以其简洁的语法和强大的...
BUPT数据库实验大三
06-29
本实验主要针对北京邮电大学（BUPT）计算机学院的大三学生，旨在通过实践加深对数据库理论的理解，提高操作数据库的能力。实验涵盖了从基础到进阶的多个方面，包括实验一至实验六，每个实验都有相应的实验报告和数据...
BUPT_RobotTeam_Libraries-机器人资源
最新发布
07-01
BUPT_RobotTeam_Libraries-机器人资源
4和7是一个幸运数字
Mr.Phoebe的专栏
04-04 6814
一个比较有趣的面试题 题意： 仅由4和7组成的十进制数字被称为幸运数字，如，4，7，44，47。 那么仅由幸运数字乘积得到的数字为超级幸运数字，如，28 = 4 * 7。 现在给你两个数字表示上下限，让你求这段区间内有多少个超级幸运数字。总共有1000组查询，上下限最多到1012101210^{12}。 思路： 第一想法是容斥搞一下，但是其实非常难，因为除了爆搜很难去构造出仅由幸运数字...
模拟退火算法分析
Mr.Phoebe的专栏
02-05 3347
一. 爬山算法 ( Hill Climbing )          介绍模拟退火前，先介绍爬山算法。爬山算法是一种简单的贪心搜索算法，该算法每次从当前解的临近解空间中选择一个最优解作为当前解，直到达到一个局部最优解。          爬山算法实现很简单，其主要缺点是会陷入局部最优解，而不一定能搜索到全局最优解。如图1所示：假设C点为当前解，爬山算法搜索到A点这个局部最优解就会停止搜索，因为
HDU 5307 He is Flying【FFT】
Mr.Phoebe的专栏
07-24 2025
题意： 有n段路，每段路长度为sis_i，你从节点i到节点j，可以获得一个开心值j−i+1j-i+1，然后问你，主人公走过了所有总长度为ss的段，问你有多少开心值。 思路： 首先想到的就是类似于组合数学那样，于是就想到了母函数： (∑ix∑si)(∑x−∑si−1)−(∑x∑si)(∑(i−1)x−∑si−1)(\sum ix^{\sum s_i})(\sum x^{-\sum s_{i-1
位运算趣题
Mr.Phoebe的专栏
09-04 1762
一个CMU的同学问了我几道题。/* * divpwr2 - Computer x/(2^n). for 0<= n <=30 * Legel ops: ! ~ & ^ | + << >> * Max ops: 15 */int divpwr(int x, int n) { int tmp = ((x^(x>>31))) + !!(x>>31))>>n; return (tmp
Google Code Jam 2018: Qualification Round
Mr.Phoebe的专栏
04-09 1702
资格赛，除了最后一题比较有趣以外，其他都比较简单 Saving The Universe Again 贪心 一开始想着尽可能将S往前移，但是想了想觉得这样移动好多次，可能才等于后面的S往前移一位的成果。 所以就变成尽可能地将C往末尾移（末尾一段连续的C就不用考虑了），即，每一次移动减少的伤害最大。 int T,n; vi a1,a2; int main() { cin&gt;&...
HDU 5035 Delivery
Mr.Phoebe的专栏
09-21 1616
公式题 概率论书上原题
BUPT 2014新生暑假个人排位赛11
Mr.Phoebe的专栏
08-06 1500
488. 小妹妹个数
HDU 5358 First One
Mr.Phoebe的专栏
08-06 1182
这题你必须严格地写出O(nlog(n))O(nlog(n))的时间复杂度，我们尝试了下O(nlog(n)2)O(nlog(n)^2)，结果不行，而且卡常数卡得特别死。首先枚举log(SUM)log(SUM)的值，从1~33，每次固定左端点ii，然后用尺取法枚举出符合位数的SUM[l,r]SUM[l,r]，这里面的sum的对数值相同，可以直接统一计算。 所以总体复杂度为O(nlog(n))O(nlo
HDU 5292 Pocket Cube
Mr.Phoebe的专栏
07-21 1062
结论题 问了学长怎么做的，学长告诉我这个结论，然后说，会玩魔方的人都知道啊… // whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algorithm> #include <iostream> #include <iomanip> #include <cstring>
BUPT信安大三上信息系统安全复习要点解析
"这是一份关于北京邮电大学（BUPT）信息安全专业大三上学期信息系统安全课程的期末复习资料，涵盖了信息系统安全的基础概念、安全威胁、保障模型、安全需求、风险管理和等级保护等方面的内容。" 在第一章中，讨论了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值