卡特兰数又称卡塔兰数，英文名Catalan number，是组合数学中一个常出现在各种计数问题中出现的数列。

以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)的名字来命名，其前几项为（从第零项开始） : 1, 1, 2, 5,

14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790,

477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324,

4861946401452, ...

卡特兰数有几条递推式：

h(n)= h(0)*h(n-1)+h(1)*h(n-2) + ... + h(n-1)h(0) (n>=2)

h(n)=h(n-1)*(4*n-2)/(n+1);

h(n)=C(2n,n)/(n+1)

h(n)=c(2n,n)-c(2n,n-1)

题目传送门：

题意：找规律

代码：

  1. #include<iostream>
  2. #include<vector>
  3. #include<deque>
  4. #include<string.h>
  5. #include<math.h>
  6. #include<stdio.h>
  7. #include<algorithm>
  8. #include<string>
  9. using namespace std;
  10.  
  11. class DividedByZeroException {};
  12.  
  13. class BigInteger {
  14. private:
  15.       vector<char> digits;
  16.       bool sign;          //  true for positive, false for negitive
  17.       void trim();        //  remove zeros in tail, but if the value is 0, keep only one:)
  18. public:
  19.       BigInteger(int);    // construct with a int integer
  20.       BigInteger(string&) ;
  21.       BigInteger();
  22.       BigInteger(const BigInteger&);
  23.       BigInteger operator=(const BigInteger& op2);
  24.  
  25.       BigInteger    abs() const;
  26.       BigInteger    pow(int a);
  27.  
  28.       //binary operators
  29.  
  30.       friend BigInteger operator+=(BigInteger&, const BigInteger&);
  31.       friend BigInteger operator-=(BigInteger&, const BigInteger&);
  32.       friend BigInteger operator*=(BigInteger&, const BigInteger&);
  33.       friend BigInteger operator/=(BigInteger&, const BigInteger&) throw(DividedByZeroException);
  34.       friend BigInteger operator%=(BigInteger&, const BigInteger&) throw(DividedByZeroException);
  35.  
  36.       friend BigInteger operator+(const BigInteger&, const BigInteger&);
  37.       friend BigInteger operator-(const BigInteger&, const BigInteger&);
  38.       friend BigInteger operator*(const BigInteger&, const BigInteger&);
  39.       friend BigInteger operator/(const BigInteger&, const BigInteger&) throw(DividedByZeroException);
  40.       friend BigInteger operator%(const BigInteger&, const BigInteger&) throw(DividedByZeroException);
  41.  
  42.       //uniary operators
  43.       friend BigInteger operator-(const BigInteger&);   //negative
  44.  
  45.       friend BigInteger operator++(BigInteger&);        //++v
  46.       friend BigInteger operator++(BigInteger&, int);   //v++
  47.       friend BigInteger operator--(BigInteger&);        //--v
  48.       friend BigInteger operator--(BigInteger&, int);   //v--
  49.  
  50.       friend bool operator>(const BigInteger&, const BigInteger&);
  51.       friend bool operator<(const BigInteger&, const BigInteger&);
  52.       friend bool operator==(const BigInteger&, const BigInteger&);
  53.       friend bool operator!=(const BigInteger&, const BigInteger&);
  54.       friend bool operator>=(const BigInteger&, const BigInteger&);
  55.       friend bool operator<=(const BigInteger&, const BigInteger&);
  56.  
  57.       friend ostream& operator<<(ostream&, const BigInteger&);   //print the BigInteger
  58.       friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger
  59.  
  60. public:
  61.       static const BigInteger ZERO;
  62.       static const BigInteger ONE;
  63.       static const BigInteger TEN;
  64. };
  65. const BigInteger BigInteger::ZERO = BigInteger();
  66. const BigInteger BigInteger::ONE = BigInteger();
  67. const BigInteger BigInteger::TEN = BigInteger();
  68.  
  69. BigInteger::BigInteger() {
  70.       sign = true;
  71. }
  72.  
  73. BigInteger::BigInteger(int val) { // construct with a int integer
  74.       if (val >= ) {
  75.             sign = true;
  76.       }
  77.  
  78.       else {
  79.             sign = false;
  80.             val *= (-);
  81.       }
  82.  
  83.       do {
  84.             digits.push_back((char)(val % ));
  85.             val /= ;
  86.       } while (val != );
  87. }
  88.  
  89. BigInteger::BigInteger(string& def) {
  90.       sign = true;
  91.  
  92.       for (string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++) {
  93.             char ch = (*iter);
  94.  
  95.             if (iter == def.rend() - ) {
  96.                   if (ch == '+') {
  97.                         break;
  98.                   }
  99.  
  100.                   if (ch == '-') {
  101.                         sign = false;
  102.                         break;
  103.                   }
  104.             }
  105.  
  106.             digits.push_back((char)((*iter) - ''));
  107.       }
  108.  
  109.       trim();
  110. }
  111.  
  112. void BigInteger::trim() {
  113.       vector<char>::reverse_iterator iter = digits.rbegin();
  114.  
  115.       while (!digits.empty() && (*iter) == ) {
  116.             digits.pop_back();
  117.             iter = digits.rbegin();
  118.       }
  119.  
  120.       if (digits.size() == ) {
  121.             sign = true;
  122.             digits.push_back();
  123.       }
  124. }
  125.  
  126. BigInteger::BigInteger(const BigInteger& op2) {
  127.       sign = op2.sign;
  128.       digits = op2.digits;
  129. }
  130.  
  131. BigInteger BigInteger::operator=(const BigInteger& op2) {
  132.       digits = op2.digits;
  133.       sign = op2.sign;
  134.       return (*this);
  135. }
  136.  
  137. BigInteger BigInteger::abs() const {
  138.       if (sign) {
  139.             return *this;
  140.       }
  141.  
  142.       else {
  143.             return -(*this);
  144.       }
  145. }
  146.  
  147. BigInteger BigInteger::pow(int a) {
  148.       BigInteger res();
  149.  
  150.       for (int i = ; i < a; i++) {
  151.             res *= (*this);
  152.       }
  153.  
  154.       return res;
  155. }
  156.  
  157. //binary operators
  158. BigInteger operator+=(BigInteger& op1, const BigInteger& op2) {
  159.       if (op1.sign == op2.sign) {     //只处理相同的符号的情况，异号的情况给-处理
  160.             vector<char>::iterator iter1;
  161.             vector<char>::const_iterator iter2;
  162.             iter1 = op1.digits.begin();
  163.             iter2 = op2.digits.begin();
  164.             char to_add = ;        //进位
  165.  
  166.             while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
  167.                   (*iter1) = (*iter1) + (*iter2) + to_add;
  168.                   to_add = ((*iter1) > );    // 大于9进一位
  169.                   (*iter1) = (*iter1) % ;
  170.                   iter1++;
  171.                   iter2++;
  172.             }
  173.  
  174.             while (iter1 != op1.digits.end()) {    //
  175.                   (*iter1) = (*iter1) + to_add;
  176.                   to_add = ((*iter1) > );
  177.                   (*iter1) %= ;
  178.                   iter1++;
  179.             }
  180.  
  181.             while (iter2 != op2.digits.end()) {
  182.                   char val = (*iter2) + to_add;
  183.                   to_add = (val > ) ;
  184.                   val %= ;
  185.                   op1.digits.push_back(val);
  186.                   iter2++;
  187.             }
  188.  
  189.             if (to_add != ) {
  190.                   op1.digits.push_back(to_add);
  191.             }
  192.  
  193.             return op1;
  194.       }
  195.  
  196.       else {
  197.             if (op1.sign) {
  198.                   return op1 -= (-op2);
  199.             }
  200.  
  201.             else {
  202.                   return op1 = op2 - (-op1);
  203.             }
  204.       }
  205.  
  206. }
  207.  
  208. BigInteger operator-=(BigInteger& op1, const BigInteger& op2) {
  209.       if (op1.sign == op2.sign) {     //只处理相同的符号的情况，异号的情况给+处理
  210.             if (op1.sign) {
  211.                   if (op1 < op2) { // 2 - 3
  212.                         return  op1 = -(op2 - op1);
  213.                   }
  214.             }
  215.  
  216.             else {
  217.                   if (-op1 > -op2) { // (-3)-(-2) = -(3 - 2)
  218.                         return op1 = -((-op1) - (-op2));
  219.                   }
  220.  
  221.                   else {           // (-2)-(-3) = 3 - 2
  222.                         return op1 = (-op2) - (-op1);
  223.                   }
  224.             }
  225.  
  226.             vector<char>::iterator iter1;
  227.             vector<char>::const_iterator iter2;
  228.             iter1 = op1.digits.begin();
  229.             iter2 = op2.digits.begin();
  230.  
  231.             char to_substract = ;  //借位
  232.  
  233.             while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
  234.                   (*iter1) = (*iter1) - (*iter2) - to_substract;
  235.                   to_substract = ;
  236.  
  237.                   if ((*iter1) < ) {
  238.                         to_substract = ;
  239.                         (*iter1) += ;
  240.                   }
  241.  
  242.                   iter1++;
  243.                   iter2++;
  244.             }
  245.  
  246.             while (iter1 != op1.digits.end()) {
  247.                   (*iter1) = (*iter1) - to_substract;
  248.                   to_substract = ;
  249.  
  250.                   if ((*iter1) < ) {
  251.                         to_substract = ;
  252.                         (*iter1) += ;
  253.                   }
  254.  
  255.                   else {
  256.                         break;
  257.                   }
  258.  
  259.                   iter1++;
  260.             }
  261.  
  262.             op1.trim();
  263.             return op1;
  264.       }
  265.  
  266.       else {
  267.             if (op1 > BigInteger::ZERO) {
  268.                   return op1 += (-op2);
  269.             }
  270.  
  271.             else {
  272.                   return op1 = -(op2 + (-op1));
  273.             }
  274.       }
  275. }
  276. BigInteger operator*=(BigInteger& op1, const BigInteger& op2) {
  277.       BigInteger result();
  278.  
  279.       if (op1 == BigInteger::ZERO || op2 == BigInteger::ZERO) {
  280.             result = BigInteger::ZERO;
  281.       }
  282.  
  283.       else {
  284.             vector<char>::const_iterator iter2 = op2.digits.begin();
  285.  
  286.             while (iter2 != op2.digits.end()) {
  287.                   if (*iter2 != ) {
  288.                         deque<char> temp(op1.digits.begin(), op1.digits.end());
  289.                         char to_add = ;
  290.                         deque<char>::iterator iter1 = temp.begin();
  291.  
  292.                         while (iter1 != temp.end()) {
  293.                               (*iter1) *= (*iter2);
  294.                               (*iter1) += to_add;
  295.                               to_add = (*iter1) / ;
  296.                               (*iter1) %= ;
  297.                               iter1++;
  298.                         }
  299.  
  300.                         if (to_add != ) {
  301.                               temp.push_back(to_add);
  302.                         }
  303.  
  304.                         int num_of_zeros = iter2 - op2.digits.begin();
  305.  
  306.                         while (num_of_zeros--) {
  307.                               temp.push_front();
  308.                         }
  309.  
  310.                         BigInteger temp2;
  311.                         temp2.digits.insert(temp2.digits.end(), temp.begin(), temp.end());
  312.                         temp2.trim();
  313.                         result = result + temp2;
  314.                   }
  315.  
  316.                   iter2++;
  317.             }
  318.  
  319.             result.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
  320.       }
  321.  
  322.       op1 = result;
  323.       return op1;
  324. }
  325.  
  326. BigInteger operator/=(BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
  327.       if (op2 == BigInteger::ZERO) {
  328.             throw DividedByZeroException();
  329.       }
  330.  
  331.       BigInteger t1 = op1.abs(), t2 = op2.abs();
  332.  
  333.       if (t1 < t2) {
  334.             op1 = BigInteger::ZERO;
  335.             return op1;
  336.       }
  337.  
  338.       //现在 t1 > t2 > 0
  339.       //只需将 t1/t2的结果交给result就可以了
  340.       deque<char> temp;
  341.       vector<char>::reverse_iterator iter = t1.digits.rbegin();
  342.  
  343.       BigInteger temp2();
  344.  
  345.       while (iter != t1.digits.rend()) {
  346.             temp2 = temp2 * BigInteger::TEN + BigInteger((int)(*iter));
  347.             char s = ;
  348.  
  349.             while (temp2 >= t2) {
  350.                   temp2 = temp2 - t2;
  351.                   s = s + ;
  352.             }
  353.  
  354.             temp.push_front(s);
  355.             iter++;
  356.       }
  357.  
  358.       op1.digits.clear();
  359.       op1.digits.insert(op1.digits.end(), temp.begin(), temp.end());
  360.       op1.trim();
  361.       op1.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
  362.       return op1;
  363. }
  364.  
  365. BigInteger operator%=(BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
  366.       return op1 -= ((op1 / op2) * op2);
  367. }
  368.  
  369. BigInteger operator+(const BigInteger& op1, const BigInteger& op2) {
  370.       BigInteger temp(op1);
  371.       temp += op2;
  372.       return temp;
  373. }
  374. BigInteger operator-(const BigInteger& op1, const BigInteger& op2) {
  375.       BigInteger temp(op1);
  376.       temp -= op2;
  377.       return temp;
  378. }
  379.  
  380. BigInteger operator*(const BigInteger& op1, const BigInteger& op2) {
  381.       BigInteger temp(op1);
  382.       temp *= op2;
  383.       return temp;
  384.  
  385. }
  386.  
  387. BigInteger operator/(const BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
  388.       BigInteger temp(op1);
  389.       temp /= op2;
  390.       return temp;
  391. }
  392.  
  393. BigInteger operator%(const BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
  394.       BigInteger temp(op1);
  395.       temp %= op2;
  396.       return temp;
  397. }
  398.  
  399. //uniary operators
  400. BigInteger operator-(const BigInteger& op) {  //negative
  401.       BigInteger temp = BigInteger(op);
  402.       temp.sign = !temp.sign;
  403.       return temp;
  404. }
  405.  
  406. BigInteger operator++(BigInteger& op) {   //++v
  407.       op += BigInteger::ONE;
  408.       return op;
  409. }
  410.  
  411. BigInteger operator++(BigInteger& op, int x) { //v++
  412.       BigInteger temp(op);
  413.       ++op;
  414.       return temp;
  415. }
  416.  
  417. BigInteger operator--(BigInteger& op) {   //--v
  418.       op -=  BigInteger::ONE;
  419.       return op;
  420. }
  421.  
  422. BigInteger operator--(BigInteger& op, int x) { //v--
  423.       BigInteger temp(op);
  424.       --op;
  425.       return temp;
  426. }
  427.  
  428. bool operator<(const BigInteger& op1, const BigInteger& op2) {
  429.       if (op1.sign != op2.sign) {
  430.             return !op1.sign;
  431.       }
  432.  
  433.       else {
  434.             if (op1.digits.size() != op2.digits.size())
  435.                   return (op1.sign && op1.digits.size() < op2.digits.size())
  436.                          || (!op1.sign && op1.digits.size() > op2.digits.size());
  437.  
  438.             vector<char>::const_reverse_iterator iter1, iter2;
  439.             iter1 = op1.digits.rbegin();
  440.             iter2 = op2.digits.rbegin();
  441.  
  442.             while (iter1 != op1.digits.rend()) {
  443.                   if (op1.sign &&  *iter1 < *iter2) {
  444.                         return true;
  445.                   }
  446.  
  447.                   if (op1.sign &&  *iter1 > *iter2) {
  448.                         return false;
  449.                   }
  450.  
  451.                   if (!op1.sign &&  *iter1 > *iter2) {
  452.                         return true;
  453.                   }
  454.  
  455.                   if (!op1.sign &&  *iter1 < *iter2) {
  456.                         return false;
  457.                   }
  458.  
  459.                   iter1++;
  460.                   iter2++;
  461.             }
  462.  
  463.             return false;
  464.       }
  465. }
  466. bool operator==(const BigInteger& op1, const BigInteger& op2) {
  467.       if (op1.sign != op2.sign  || op1.digits.size() != op2.digits.size()) {
  468.             return false;
  469.       }
  470.  
  471.       vector<char>::const_iterator iter1, iter2;
  472.       iter1 = op1.digits.begin();
  473.       iter2 = op2.digits.begin();
  474.  
  475.       while (iter1 != op1.digits.end()) {
  476.             if (*iter1 != *iter2) {
  477.                   return false;
  478.             }
  479.  
  480.             iter1++;
  481.             iter2++;
  482.       }
  483.  
  484.       return true;
  485. }
  486.  
  487. bool operator!=(const BigInteger& op1, const BigInteger& op2) {
  488.       return !(op1 == op2);
  489. }
  490.  
  491. bool operator>=(const BigInteger& op1, const BigInteger& op2) {
  492.       return (op1 > op2) || (op1 == op2);
  493. }
  494.  
  495. bool operator<=(const BigInteger& op1, const BigInteger& op2) {
  496.       return (op1 < op2) || (op1 == op2);
  497. }
  498.  
  499. bool operator>(const BigInteger& op1, const BigInteger& op2) {
  500.       return !(op1 <= op2);
  501. }
  502.  
  503. ostream& operator<<(ostream& stream, const BigInteger& val) {  //print the BigInteger
  504.       if (!val.sign) {
  505.             stream << "-";
  506.       }
  507.  
  508.       for (vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++) {
  509.             stream << (char)((*iter) + '');
  510.       }
  511.  
  512.       return stream;
  513. }
  514.  
  515. istream& operator>>(istream& stream, BigInteger& val) {   //Input the BigInteger
  516.       string str;
  517.       stream >> str;
  518.       val = BigInteger(str);
  519.       return stream;
  520. }
  521.  
  522. #define maxn 105
  523. BigInteger a[maxn];
  524. int main() {
  525.        int B;
  526.        a[]=;
  527.        for(int i=;i<=maxn;i++)
  528.        {
  529.            a[i]=a[i-]*(*i-)/(i+);
  530.        }
  531.         while(cin >>B){
  532.         cout<<a[B]<<endl;
  533.         }
  534.         /*cout << "A-B:" << A - B << endl;
  535.         cout << "A+B:" << A + B << endl;
  536.         cout << "A*B:" << A*B << endl;
  537.         cout << "A/B:" << A / B << endl;
  538.         cout << "A%B:" << A % B << endl;
  539.         cout <<  A.pow(B-3) << endl;
  540.         A++;
  541.         cout << "A++:" << A << endl;
  542.         A--;
  543.         cout << "A--:" << A << endl;
  544.         cout << "++B:" << ++B << endl;
  545.         cout << "--B:" << --B << endl;
  546.         cout << "C:" << C << endl;*/
  547. }

卡特兰数+大数

卡特兰数的应用还有很多，可以借鉴这个博客：https://blog.csdn.net/zuzhiang/article/details/77966726( 里面有关于其在一些题目的应用 )

附上求卡特兰常数的模板：

  1. const int C_maxn = 1e4 + ;
  2. LL CatalanNum[C_maxn];
  3. LL inv[C_maxn];
  4. inline void Catalan_Mod(int N, LL mod)
  5. {
  6.     inv[] = ;
  7.     for(int i=; i<=N+; i++)///线性预处理 1 ~ N 关于 mod 的逆元
  8.         inv[i] = (mod - mod / i) * inv[mod % i] % mod;
  9.  
  10.     CatalanNum[] = CatalanNum[] = ;
  11.  
  12.     for(int i=; i<=N; i++)
  13.         CatalanNum[i] = CatalanNum[i-] * ( * i - ) %mod * inv[i+] %mod;
  14. }

卡特兰常数模板

参考博客：http://www.cnblogs.com/Rubbishes/p/9468916.html

hdu 1130How Many Trees?(卡特兰数）的更多相关文章

  1. HDU 5673 Robot【卡特兰数】

    题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=5673 题意: 有一个机器人位于坐标原点上.每秒钟机器人都可以向右移到一个单位距离,或者在原地不动.如 ...

  2. HDU 5673 Robot ——（卡特兰数）

    先推荐一个关于卡特兰数的博客:http://blog.csdn.net/hackbuteer1/article/details/7450250. 卡特兰数一个应用就是,卡特兰数的第n项表示,现在进栈和 ...

  3. HDU 4828 Grids（卡特兰数+乘法逆元）

    首先我按着我的理解说一下它为什么是卡特兰数,首先卡特兰数有一个很典型的应用就是求1~N个自然数出栈情况的种类数.而这里正好就对应了这种情况.我们要满足题目中给的条件,数字应该是从小到大放置的,1肯定在 ...

  4. hdu 1130 How Many Trees? 【卡特兰数】

    题目 题意:给你一个数字n,问你将1~n这n个数字,可以组成多少棵不同的二叉搜索树. 1,2,5,14--根据输出中的规律可以看出这是一个卡特兰数的序列.于是代用卡特兰数中的一个递推式: 因为输入可取 ...

  5. 【HDU 5370】 Tree Maker（卡特兰数+dp）

    Tree Maker Problem Description Tree Lover loves trees crazily. One day he invents an interesting gam ...

  6. hdu 1130，hdu 1131(卡特兰数,大数)

    How Many Trees? Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)T ...

  7. hdu 4828 Grids(拓展欧几里得+卡特兰数)

    题目链接:hdu 4828 Grids 题目大意:略. 解题思路:将上一行看成是入栈,下一行看成是出栈,那么执着的方案就是卡特兰数,用递推的方式求解. #include <cstdio> ...

  8. HDU 4828 (卡特兰数+逆)

    HDU 4828 Grids 思路:能够转化为卡特兰数,先把前n个人标为0.后n个人标为1.然后去全排列,全排列的数列.假设每一个1的前面相应的0大于等于1,那么就是满足的序列,假设把0看成入栈,1看 ...

  9. HDU 6084 寻找母串（卡特兰数）

    [题目链接] http://acm.hdu.edu.cn/showproblem.php?pid=6084 [题目大意] 对于一个串S,当它同时满足如下条件时,它就是一个01偏串: 1.只由0和1两种 ...

随机推荐

  1. 【学习总结】GirlsInAI ML-diary day-20-初识 Kaggle

    [学习总结]GirlsInAI ML-diary 总 原博github链接-day20 初识kaggle 1-注册一个账号(由于被谷歌收购,因此可能需要梯子) 2-Competition - 学会看一 ...

  2. mySql配置在nodejs中使用

    mySql安装完成后,配置链接nodejs项目中的数据库. 1.测试是否安装成功. 2.use nodejs使用nodejs 3.设置数据源 5.exit

  3. elasticsearch 深入 —— 结构化搜索

    结构化搜索 结构化搜索(Structured search) 是指有关探询那些具有内在结构数据的过程.比如日期.时间和数字都是结构化的:它们有精确的格式,我们可以对这些格式进行逻辑操作.比较常见的操作 ...

  4. 四、局域网连接SqlServer

    一.局域网连接SqlServer 一台服务器上装有四个数据库的时候,我们可以通过IP\实例名的方式进行访问. navicat 连接sqlserver数据库

  5. C Primer Plus 学习 第三章

    这里只记录我自己以前不懂得地方,明白的地方就略过了 位  字节  字 位    0,1 字节  8位  也就有8位0,1的组合   2的8次方的组合 字      设计计算机时给定的自然存储单元.8位 ...

  6. Java面向对象的特征与含义

    面向对象的主要特征包括抽象.继承.封装和多态. 抽象 把一个类对象的共同特征总结出来,构造新类的过程. 继承 从已有类中得到继承信息,创建新类的过程. 封装 把数据和对数据的操作绑定起来,对数据的访问 ...

  7. 解决python中转化成json的方法不能序列化datetime类型数据（转）

    Python自带的json.dumps方法序列化数据时候如果格式化的数据中有datetime类型数据时候会提示错误TypeError: datetime.datetime(2012, 12, 12, ...

  8. Center os 用户环境变量

    vi ~/.bash_profile进入用户环境变量设置 export JAVA_HOME=/usr/java/jdk1.7.0_76export JAVA_BIN=$JAVA_HOME/binexp ...

  9. python之 matplotlib模块之绘制堆叠柱状图

    我们先来看一个结果图 看到这个图,我个人的思路是 1 设置标题 import numpy as np import matplotlib.pyplot as plt plt.title('Scores ...

  10. [转]Win10企业版无法访问共享文件夹

    Win10系统电脑在更新后,当我们访问共享文件夹时可能会出现如下图所示窗口,导致我们无法访问.那么这个问题如何解决呢?具体如下:1. 首先我们按“Windows+R键”打开运行窗口.2. 在该窗口文本 ...