精华内容
参与话题
问答
  • 赤裸裸的使用的博弈的原理,但是却用DP的方法记录状态。收获颇多。 /* ID:bysen LANG:C++ PROG:game1 */ #include using namespace std; int sum[101][101]; int dp[101][101]; int num[101]; int max( int a,int...

    想了很久,看了下题解顿悟了!赤裸裸的使用的博弈的原理,但是却用DP的方法记录状态。收获颇多。

    /*
    ID:bysen
    LANG:C++
    PROG:game1
    */
    #include<stdio.h>
    using namespace std;
    
    int sum[101][101];
    int dp[101][101];
    int num[101];
    
    int max( int a,int b ){ return a>b?a:b; }
    int min( int a,int b ){ return a<b?a:b; }
    
    int main()
    {
     	freopen( "game1.in","r",stdin );
     	freopen( "game1.out","w",stdout );
     	int n;
     	scanf( "%d",&n );
     	for( int i=1;i<=n;i++ )
     	{
     		 scanf( "%d",&num[i] );
     		 dp[i][i]=sum[i][i]=num[i];
    	}
    	
    	for( int i=1;i<=n;i++ )
    	for( int j=i+1;j<=n;j++ )
    	 	 sum[i][j]=sum[i][j-1]+sum[j][j];
     	
     	for( int i=n-1;i>=1;i-- )
    	for( int j=i+1;j<=n;j++ ) 
    		 dp[i][j]=sum[i][j]-min( dp[i+1][j],dp[i][j-1] );
        /*
        for( int i=1;i<=n;i++ )
        {
         	 for( int j=i+1;j<=n;j++ )
    		 	  printf( "%d-%d:%d  ",i,j,dp[i][j] );
    		 printf( "\n" );
        }
        */
    	printf( "%d %d\n",dp[1][n],sum[1][n]-dp[1][n] );
     	
    	return 0;
    }
    


    展开全文
  • CC_CALLBACK原理及应用

    2017-01-09 11:26:00
    http://my.oschina.net/u/555701/blog/219844c++ 11基础 :std::function类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标进行存储、复制、和调用操作,这些目标包括...

    c++ 11 基础 :

        std::function

            类模版 std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标进行存储、复制、和调用操作,这些目标包括函数、lambda表达式、绑定表达式、以及其它函数对象等。

    用法示例:

    ①保存自由函数

    void printA(int a){
        cout<<a<<endl;
    }
    
     std::function<void(int a)> func;
     func = printA;
     func(2);

    运行输出: 2

    ②保存lambda表达式

    std::function<void()> func_1 = [](){cout<<"hello world"<<endl;};
        func_1();

    运行输出:hello world

    ③保存成员函数

    struct Foo {
        Foo(int num) : num_(num) {}
        void print_add(int i) const cout << num_+i << '\n'; }
        int num_;
    };
    
     // 保存成员函数std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
        Foo foo(2);
        f_add_display(foo, 1);

        运行输出: 3

        bind        bind是一组用于函数绑定的模板。在对某个函数进行绑定时,可以指定部分参数或全部参数,也可以不指定任何参数,还可以调整各个参数间的顺序。对于未指定的参 数,可以使用占位符_1、_2、_3来表示。_1表示绑定后的函数的第1个参数,_2表示绑定后的函数的第2个参数,其他依次类推。

    下面通过程序例子了解一下用法:

    #include <iostream>using namespace std;
    class A
    {
    public:
        void fun_3(int k,int m){
            cout<<k<<" "<<m<<endl;
        }
    };
    
    void fun(int x,int y,int z){
        cout<<x<<"  "<<y<<"  "<<z<<endl;
    }
    
    void fun_2(int &a,int &b){
        a++;
        b++;
        cout<<a<<"  "<<b<<endl;
    }
    
    int main(int argc, const char * argv[]){
        auto f1 = bind(fun,1,2,3); //表示绑定函数 fun 的第一,二,三个参数值为: 1 2 3
        f1(); //print:1  2  3auto f2 = bind(fun, placeholders::_1,placeholders::_2,3);
        //表示绑定函数 fun 的第三个参数为 3,而fun 的第一,二个参数分别有调用 f2 的第一,二个参数指定
        f2(1,2);//print:1  2  3auto f3 = bind(fun,placeholders::_2,placeholders::_1,3);
        //表示绑定函数 fun 的第三个参数为 3,而fun 的第一,二个参数分别有调用 f3 的第二,一个参数指定//注意: f2  和  f3 的区别。
        f3(1,2);//print:2  1  3int n = 2;
        int m = 3;
        
        auto f4 = bind(fun_2, n,placeholders::_1);
        f4(m); //print:3  4cout<<m<<endl;//print:4  说明:bind对于不事先绑定的参数,通过std::placeholders传递的参数是通过引用传递的cout<<n<<endl;//print:2  说明:bind对于预先绑定的函数参数是通过值传递的
        
        
        A a;
        auto f5 = bind(&A::fun_3, a,placeholders::_1,placeholders::_2);
        f5(10,20);//print:10 20std::function<void(int,int)> fc = std::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
        fc(10,20);//print:10 20return 0;
    }

        CC_CALLBACK

            一、通过 HelloWorldScene 中的 closeItem 开始

    在cocos2d-x 2.x 版本中:

    CCMenuItemImage *pCloseItem = CCMenuItemImage::create(
                                            "CloseNormal.png",
                                            "CloseSelected.png",
                                            this,
                                            menu_selector(HelloWorld::menuCloseCallback));

    在cocos2d-x 3.0 版本中:

    auto closeItem = MenuItemImage::create(
                                               "CloseNormal.png",
                                               "CloseSelected.png",
                                               CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));


    void HelloWorld::menuCloseCallback(ObjectpSender)
    {
        Director::getInstance()->end();
    
    #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
        exit(0);
    #endif
    }

    注意到在3.0版本中使用到 CC_CALLBACK_1 这样一个宏定义。

    // new callbacks based on C++11#define CC_CALLBACK_0(__selector__,__target__, ...) std::bind(&__selector__,__target__, ##__VA_ARGS__)
    #define CC_CALLBACK_1(__selector__,__target__, ...) std::bind(&__selector__,__target__std::placeholders::_1, ##__VA_ARGS__)
    #define CC_CALCC_CALLBACK_1(HelloWorld::menuCloseCallback,this)LBACK_2(__selector__,__target__, ...) std::bind(&__selector__,__target__std::placeholders::_1std::placeholders::_2, ##__VA_ARGS__)
    #define CC_CALLBACK_3(__selector__,__target__, ...) std::bind(&__selector__,__target__std::placeholders::_1std::placeholders::_2std::placeholders::_3 ##__VA_ARGS__)

    这里主要注意两点:一是 std::bind,二是##_VA_ARGS_; ##_VA_ARGS_是可变参数宏

    原来还有 CC_CALLBACK_0 1 2 3;而其中又有什么区别呢?

    1、首先我们看看3.0版本中MenuItemImage的create方法:

    MenuItemImage * MenuItemImage::create(const std::string& normalImage, const std::string& selectedImage, const ccMenuCallback& callback)

    其中的回调参数是 ccMenuCallback 

    typedef std::function<void(Object*)> ccMenuCallback

    来这里使用到了 C++ 中的 function 语法。

    注意到 在 CC_CALLBACK_  的宏定义的中使用到的是 C++ 的 bind 语法,怎么不一致了呢? -- 见下面第四点 function


    2、看回 CC_CALLBACK_  的宏定义

    原来 CC_CALLBACK_  的宏定义中后面的 0 1 2 3分别表示的是 不事先指定回调函数参数的个数。

    例如说 CC_CALLBACK_ 1 表示的是,回调函数中不事先指定参数是一个,而事先指定的回调函数的参数 可以任意多个

    而且要注意到其中 不指定回调函数参数  和  指定回调函数参数  的顺序,注意不事先指定的在前,事先指定的在后

    下面通过例子说明这一点:

    假设回调函数:

    // a selector callbackvoid menuCloseCallback(Object* pSender,int a,int b);
    void HelloWorld::menuCloseCallback(Object* pSender,int a,int b)
    {
        std::cout<<a<<"  "<<b<<std::endl;
        Director::getInstance()->end();
    
    #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)exit(0);
    #endif
    }

    注意到在回调函数中输出 a b

    auto closeItem = MenuItemImage::create(
                                               "CloseNormal.png",
                                               "CloseSelected.png",
                                               CC_CALLBACK_1(HelloWorld::menuCloseCallback,this,1,2));


    注意中其中 指定了两个参数 1 2 

    运行,在 点击closeItem  的时候,就会输出这两个事先指定的参数 1  2。

    那么,不事先指定的参数是在什么时候传入的呢?

    void MenuItem::activate()
    {
        if (_enabled)
        {
            if_callback )
            {
                _callback(this);
            }
            
            if (kScriptTypeNone != _scriptType)
            {
                BasicScriptData data(this);
                ScriptEvent scriptEvent(kMenuClickedEvent,&data);
                ScriptEngineManager::getInstance()->getScriptEngine()->sendEvent(&scriptEvent);
            }
        }
    }

        注意到其中的  _callback(this);  对了,这个时候就传入了 这个不事先指定的回调函数参数。

    这样,closeItem 的回调函数的 void HelloWorld::menuCloseCallback(Object* pSender,int a,int b) 的三个参数都知道了。

    第一个 不事先指定,在menu item调用 activate 的时候,_callback(this) 传入,this 也即是这个 menu item;第二、三个参数是事先指定的 1,2。


    已经知道  CC_CALLBACK_  的宏定义是 std::bind 那么我们可以直接使用std::bind。

    如下:

    auto closeItem = MenuItemImage::create(
                                               "CloseNormal.png",
                                               "CloseSelected.png",
                                              std::bind(&HelloWorld::menuCloseCallback, this,std::placeholders::_1,1,2));





    转载于:https://www.cnblogs.com/feizuzu/p/5dc5516aac441c91a412a51a3d3ff236.html

    展开全文
  • cf 547C 容斥原理

    2015-06-03 00:36:21
    #include #include #include #include #define ll long long using namespace std; const int N =500000+10; vector fac[N]; int vis[N],cnt[N],v[N]; int n,q,a[N];...void dfs(int u,in
    #include <iostream>
    #include<stdio.h>
    #include<algorithm>
    #include<vector>
    #define ll long long
    using namespace std;
    const int N =500000+10;
    vector<int> fac[N];
    int vis[N],cnt[N],v[N];
    int n,q,a[N];
    ll ans;
    int x;
    void dfs(int u,int mul,int tp,int bo)
    {
        if(u==fac[x].size())
        {
            if(bo) cnt[mul]--;
            ans+=tp*cnt[mul];//当前mul的倍数有多少个
            if(!bo) cnt[mul]++;
            return ;
        }
        dfs(u + 1, mul * 1, tp, bo);
        dfs(u + 1, mul * fac[x][u], -tp, bo);
    }
    int main()
    {
        //分解质因子
        for(int i=2;i<N;i++)
        {
            if(v[i]) continue;
            for(int j=i;j<N;j+=i)
            {
              v[j]=1;
              fac[j].push_back(i);
            }
        }
        scanf("%d%d",&n,&q);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        while(q--)
        {
            scanf("%d",&x);
            if(vis[x])
            {
                vis[x]=0;
                x=a[x];
                dfs(0,1,-1,1);
            }
            else
            {
                vis[x] = 1;
                x = a[x];
                dfs(0, 1, 1, 0);
            }
             printf("%I64d\n", ans);
        }

    }

    展开全文
  • C++虚函数的底层实现原理

    千次阅读 2018-05-27 15:49:36
    原文链接:https://blog.csdn.net/u011000290/article/details/50498683在C++中,多态是利用虚函数来实现的。比如说,有如下代码:[cpp] view ... using namespace std; class Animal { public: void Cry(...

    原文链接:https://blog.csdn.net/u011000290/article/details/50498683

    在C++中,多态是利用虚函数来实现的。比如说,有如下代码:

    1. #include <iostream>  
    2. using namespace std;  
    3. class Animal  
    4. {  
    5. public:  
    6.     void Cry()  
    7.     {  
    8.         cout << "Animal cry!" << endl;  
    9.     }  
    10. };  
    11. class Dog :public Animal  
    12. {  
    13. public:  
    14.     void Cry()  
    15.     {  
    16.         cout << "Wang wang!" << endl;  
    17.     }  
    18. };  
    19. void MakeAnimalCry(Animal& animal)  
    20. {  
    21.     animal.Cry();  
    22. }  
    23. int main()  
    24. {  
    25.     Dog dog;  
    26.     dog.Cry();  
    27.     MakeAnimalCry(dog);  
    28.     return 0;  
    29. }  

    输出如下图:

    这里定义了一个Animal类,Dog类继承该类,并覆盖了它的Cry方法。有一个MakeAnimalCry方法,传入了Animal的引用,传入了dog对象,但是输出确是Animal的输出。理想的情况下,用户希望传入的是dog对象,就该调用dog的Cry方法。要实现这种多态行为,需要将Animal::Cry()声明为虚函数。可以通过Animal指针或者Animal引用来访问Animal对象,这种指针或者引用可以指向Animal、Dog、Cat对象,而不需要关心它们具体指向的是哪种对象。修改代码如下:

    1. #include <iostream>  
    2. using namespace std;  
    3. class Animal  
    4. {  
    5. public:  
    6.     virtual void Cry()  
    7.     {  
    8.         cout << "Animal cry!" << endl;  
    9.     }  
    10. };  
    11. class Dog :public Animal  
    12. {  
    13. public:  
    14.     void Cry()  
    15.     {  
    16.         cout << "Wang wang!" << endl;  
    17.     }  
    18. };  
    19. class Cat:public Animal  
    20. {  
    21. public:  
    22.     void Cry()  
    23.     {  
    24.         cout << "Meow meow" << endl;  
    25.     }  
    26. };  
    27. void MakeAnimalCry(Animal& animal)  
    28. {  
    29.     animal.Cry();  
    30. }  
    31. int main()  
    32. {  
    33.     Dog dog;  
    34.     Cat cat;  
    35.     //dog.Cry();  
    36.     MakeAnimalCry(dog);  
    37.     MakeAnimalCry(cat);  
    38.     return 0;  
    39. }  

    修改后的输出如下:


    这就是多态的效果,将派生类对象视为基类对象,并执行派生类的Cry实现。如果基类指针指向的是派生类对象,通过该指针调用运算符delete时,即对于使用new在自由存储区中实例化的派生类对象,如果将其赋给基类指针,并通过该指针调用delete,将不会调用派生类的析构函数。这可能会导致资源未释放、内存泄露等问题,为了避免这种问题,可以将基类的析构函数声明为虚函数

    在上面的程序中,演示了多态的效果,即在函数MakeAnimalCry中,虽然通过Animal引用调用Cry方法,但是实际调用的确是Dog::Cry或者Cat::Cry方法。在编译阶段,编译器并不知道将要传递给该函数的是哪种对象,无法确保在不同的情况下执行不同的Cry方法。应该调用哪个Cry方法显然是在运行阶段决定的。这是使用多态的不可见逻辑实现的,而这种逻辑是编译器在编译阶段提供的。下面详细地说明一下虚函数的底层实现原理。

    比如说有下面的基类Base,它声明了N个虚函数:

    1. class Base  
    2. {  
    3. public:  
    4.     virtual void Func1()  
    5.     {  
    6.         //Func1的实现代码   
    7.     }  
    8.     virtual void Func2()  
    9.     {  
    10.         //Func2的实现代码   
    11.     }  
    12.     //Func3、Func4等虚函数的实现   
    13.     virtual void FuncN()  
    14.     {  
    15.         //FuncN的实现代码   
    16.     }  
    17. };  

    下面的Derived类继承了Base类,并且覆盖了除Func2之外的其他所有虚函数,

    1. class Derived:public Base  
    2. {  
    3. public:  
    4.     virtual void Func1()  
    5.     {  
    6.         //Func2覆盖Base类的Func1代码   
    7.     }  
    8.     //除去Func2的其他所有虚函数的实现代码   
    9.     virtual void FuncN()  
    10.     {  
    11.         //FuncN覆盖Base类的FuncN代码   
    12.     }  
    13. };  

    编译器见到这种继承层次结构后,知道Base定义了虚函数,并且在Derived类中覆盖了这些函数。在这种情况下,编译器将为实现了虚函数的基类和覆盖了虚函数的派生类分别创建一个虚函数表(Virtual Function Table,VFT)。也就是说Base和Derived类都将有自己的虚函数表。实例化这些类的对象时,将创建一个隐藏的指针VFT*,它指向相应的VFT。可将VFT视为一个包含函数指针的静态数组,其中每个指针都指向相应的虚函数。Base类和Derived类的虚函数表如下图所示:


    每个虚函数表都由函数指针组成,其中每个指针都指向相应虚函数的实现。在类Derived的虚函数表中,除一个函数指针外,其他所有的函数指针都指向本地的虚函数实现。Derived没有覆盖Base::Func2,因此相应的虚函数指针指向Base类的Func2的实现。这就意味着,当执行下面的代码时,编译器将查找Derived类的VFT,确保调用Base::Func2的实现:

    1. Derived objDerived;  
    2. objDerived.Func2();  

    调用被覆盖的方法时,也是这样:

    1. void DoSomething(Base& objBase)  
    2. {  
    3.     objBase.Func1();  
    4. }  
    5. int main()  
    6. {  
    7.     Derived objDerived;  
    8.     DoSomething(objDerived);  
    9. }  

    在这种情况下,虽然将objDerived传递给了objBase,进而被解读成一个Base实例,但该实例的VFT指针仍然指向Derived类的虚函数表,因此通过该VFT执行的是Derived::Func1.虚函数表就是通过上面的方式来实现C++的多态。

    要验证虚函数表的存在其实也很简单,可以通过比较同一个类,一个包含虚函数,一个不包含,对比其大小就知道了。

    1. #include <iostream>  
    2. using namespace std;  
    3. class Test   
    4. {  
    5. public:  
    6.     int a,b;  
    7.     void DoSomething()  
    8.     {   }   
    9. };  
    10. class Base  
    11. {  
    12. public:  
    13.     int a,b;  
    14.     virtual void DoSomething()  
    15.     {   }   
    16. };  
    17. int main()  
    18. {  
    19.     cout<<"sizeof(Test):"<<sizeof(Test)<<endl;  
    20.     cout<<"sizeof(Base):"<<sizeof(Base)<<endl;  
    21.     return 0;  
    22. }  

    执行输出如下:


    虽然两个类几乎相同,因为Base中的DoSomething方法是一个虚函数,编译器为Base类生成了一个虚函数表,并为其虚函数表指针预留空间,所以Base类占用的内存空间比Test类多了8个字节。



    展开全文
  • 参考链接:https://blog.csdn.net/u011086209/article/details/92809649 1.智能指针 智能指针是一个类,这个类的构造函数中传入一个...1)std::auto_ptr,有很多问题。 不支持复制(拷贝构造函数)和赋值(operator
  • 传送门  其中x为幸运数字 我们先预处理出幸运数字 , 然后将之间成倍数关系的去处 最后容斥原理奇加偶减统计答案就可以了 #include&lt;bits/stdc++.h&...using namespace std;...void Init(LL u...
  • #include&lt;cstdio&gt; #include&lt;algorithm&...using namespace std; const int maxn=1000+10; const int maxm=20000+10; struct Edge { int u,v,dist; Edge(){} Edge(...
  • Linux之ARM(MX6U)裸机之使用官方 SDK 移植实验1. I.MX6ULL 官方 SDK 包简介2.硬件原理图分析3.试验程序编写3.1SDK 文件移植3.2创建 cc.h 文件3.3 编写实验代码4.编译下载验证4.1 编写 Makefile 和链接脚本4.2 编译...
  • 题意如图。 思路: 有公式 ∁(1,i)+∁(2,i)+...+∁(n,i)=∁(n+1,i+1)\complement (1,i) + \complement ...然后用容斥原理写就可以了。 放代码: #include<bits/stdc++.h> using namespace std; const int N=1e6+.
  • 代码语法错误分析工具pclint8.0

    热门讨论 2010-06-29 07:00:09
    arguments: $(FileDir) -name *.c -o -name *.cpp | C:\unix\usr\local\wbin\xargs lint-nt -i"c:\unix\usr\local" -u c:\pclint\std.lnt c:\pclint\env-vc6.lnt (iii)Use Output Window打上勾,close退出。好了,...
  • 大学文献检索资料 DOC

    2009-11-28 10:35:24
    R ( 电气) S 、T 、U 、V 、W 、X CH ( 化工) A 、B 、C 、D 、E 、F G 、H 、J 、K 、L 、M 德温特专利文献检索工具的符号体系及名词解释:专利权人代码后的“-”号,表示小公司。“/”号,表示个人。 “=”...
  • knn算法C++实现

    千次阅读 2016-05-12 21:02:39
    knn的C++实现,有不对的...knn原理请见:http://blog.csdn.net/u013593585/article/details/51284537 #include #include #include #include #include using namespace std; typedef vector Tuple; const int k =
  • e6Z9i~]8R~U~QHE{RnY{QXg~QnQ{^XVlRXlp^XI5Q6Q6SKY8jUAA 首先观察,发现有数字有字母有符号,结尾是双A,类似base64 ==与AA的ASCII码相差4 (原理类似凯撒) 写一个简单的c++代码实现 #include <bits/stdc++.h&...
  • Boost signal 代码示例

    千次阅读 2015-01-23 16:38:47
    网上介绍Boost signal原理的文章很多,这里不介绍原理,仅贴一些示例代码,这在初步接触Boost signal时能够有个较好的感性认识,深入了解需要去体会挖掘boost源码。代码基本上来自Boost turioal,其中有一些错误会...
  • using namespace std; const int g_kMaxs = 1000000; bool g_u[g_kMaxs+1]; vector g_primer; void Init() { g_primer.clear(); /* 下面是素数的欧拉筛法: 该法优化的原理是保证 每个合数仅被它最
  • 9-8 (kruskal水)

    2017-09-09 09:05:32
    Slim span求一棵生成树使最大的边...注意并查集的使用+kruskal基本思路与原理#include using namespace std; int n, m; const int maxn = 110; const int INF = 0x3f3f3f3f; int fa[maxn]; struct edge{ int u, v, w
  • 基于vector<...基数排序原理如链接https://blog.csdn.net/u012580566/article/details/47702955 #include<iostream> #include<vector> using namespace std; struct node { int val; no...
  • 描述:最小树形图—-一个有向...原理:朱刘算法及相关定理。 代码 :#include<bits\stdc++.h> using namespace std; typedef int CostType;struct Edge{ int u; int v; CostType cost; Edge(){}; Edge(int x,in
  • 1、原理:在剩下的所有未选取的边中,找最小边,如果和已选取的边构成回路,则放弃,选取次小边(加边法)。   #include&lt;bits/stdc++.h&gt; using namespace std; struct Edge{ int u,v,w; }; ...
  • HDU-3952-Fruit Ninja

    2015-07-14 15:43:52
    这个博客解释原理解释的很好,我就不再多加解释什么了,有兴趣的可以看一下;http://m.blog.csdn.net/blog/u013480600/39546795#include #include #include #include #include #include #include #include #include ...
  • 最小生成树kruskal算法

    2017-03-29 20:29:19
    原理:最小生成树的相关定理。代码:#include using namespace std;typedef int CostType;class Edge{ public: int u; int v; CostType cost; Edge(){} Edge(int x,int y,CostType c):u(x),
  • Pair

    2019-01-02 21:07:26
    基本的容斥原理 没有任何一个划分 =&gt; 枚举至少有哪些划分 有 n-1 个限制,限制是x=2…n 不是一个合法的划分位置,枚举一些强制违反的限制即可 #include&lt;bits/stdc++.h&gt; #define mod 1000000000...
  • 最小生成树

    2017-11-13 12:40:41
    原理但是kruskal的源码需要修改下……代码给的不好 kruskal:#include #include #include #define N 150 using namespace std; int m,n,u[N],v[N],w[N],p[N],r[N]; //r是边的编号 //p是点的祖先点(便于判断是否...
  • 此算法为算法导论>中第24章第2小节关于single-source shortest paths in directed graphs原理的实现. 原著P592 #include using namespace std; #define MAX 32767 int N,M; int u,v,l,pos; int w[1000][1000]...
  • 关于问题的数学原理,可以参看布鲁迪(Richard A.Brualdi)写的组合数学,这里不赘述,直接上代码,请指教 #include using namespace std; int CpuNum(int EqualNum,int Sum)//转载请注明出处...
  • 树的重心

    2020-10-04 14:25:57
    //原理是先用son[u]表示出所有的子节点 //如果把一个点取出来,那么会生成一定的树 //其中一些子树大小为son[v] //还有一个以原先根节点的父亲树为son[根节点]-sum[u] //Nice!!! #include #include #include #...
  • 题目链接 题解: 让我们找到第k个没有平方...然后根据容斥原理求出区间内有多少个没有平方因子的数。 #include <bits/stdc++.h> #define int long long using namespace std; typedef long long ll; const ...
  • 通过画图可以发现,要使得边不能相交那么以u为根的子树一定要在圈上连续。那么我们先C(n,1)C(n,1)C(n,1)选出一个数为根然后,他的子树的序列的全排列都是满足的,所以乘法原理分别相乘就可以了。 #include <bits/...

空空如也

1 2
收藏数 29
精华内容 11
关键字:

ustd原理