代码片段

1
#include <objbase.h>
2

3
GUID CreateGuid() {
4
    GUID guid;
5
    if (CoCreateGuid(&guid) == S_OK) {
6
        return guid;
7
    }
8
    throw exception("generate guid failed!");
9
}
10

11
string GuidToString(const GUID& guid) {
12
    char buf[64] = { 0 };
13
    snprintf(buf, sizeof(buf),
14
        "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
15
        guid.Data1, guid.Data2, guid.Data3,
16
        guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
17
        guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
18
    return string(buf);
19
}

1
#include <vector>
2
class Matrix : public std::vector<std::vector<double> > {
3
public:
4
  void Init(int row, int col) {
5
    assign(row, vector<double>());
6
    for (int i = 0; i < row; i++) {
7
      at(i).assign(col, 0);
8
    }
9
  }
10
};
11
/*要求系数矩阵可逆
12
此处A为增广矩阵，即A[i][n]为第i个方程右边的常数bi
13
运行结束后A[i][n]为第i个未知数的值 */
14
void gauss_elimination(std::vector<std::vector<double> >& A, int n) {
15
  int i, j, k, r;
16
  //消元过程
17
  for (i = 0; i < n; i++) {
18
    //选一行r并与第i行交换
19
    r = i;
20
    for (j = i + 1; j < n; j++) {
21
      if (fabs(A[j][i]) > fabs(A[r][i])) {
22
        r = j;
23
      }
24
    }
25
    if (r != i) {
26
      for (j = 0; j <= n; j++) {
27
        std::swap(A[r][j], A[i][j]);
28
      }
29
    }
30
    //与第i+1至第n行进行消元
31
    for (k = i + 1; k < n; k++) {
32
      double f = A[k][i] / A[i][i];
33
      for (j = i; j <= n; j++) {
34
        A[k][j] -= f * A[i][j];
35
      }
36
    }
37
  }
38
  //回代过程
39
  for (i = n - 1; i >= 0; i--) {
40
    for (j = i + 1; j < n; j++) {
41
      A[i][n] -= A[j][n] * A[i][j];
42
    }
43
    A[i][n] /= A[i][i];
44
  }
45
}

1
#include <iostream>
2

3
// 高斯消元，定义在上一节
4
void gauss_elimination(std::vector<std::vector<double> >& A, int n)
5
inline bool fequal(double a, double b) {
6
  return fabs(a - b) < 1e-6;
7
}
8
void fxformatprint(std::vector<std::vector<double> > a, int n) {
9
  bool first = 1;
10
  int last = 0;
11
  std::cout << std::fixed << "f(x)=";
12
  for (int i = 0; i < n; i++) {
13
    if (fequal(a[i][n], 0)) {
14
      continue;
15
    }
16
    last = i;
17
    if (a[i][n] > 0 && !first) {
18
      std::cout << '+';
19
    }
20
    if (!fequal(a[i][n], 1)) {
21
      if (fequal(a[i][n], -1)) {
22
        std::cout << '-';
23
      }
24
      else {
25
        std::cout << a[i][n];
26
      }
27
    }
28
    if (n - (i + 1) > 1) {
29
      std::cout << "x^" << n - (i + 1);
30
    }
31
    else if (n - (i + 1) == 1) {
32
      std::cout << "x";
33
    }
34
    first = 0;
35
  }
36
  if (fequal(a[last][n], -1)) {
37
    std::cout << 1;
38
  }
39
}
40
// 仅支持{(1, a1),(2, a2),...,(n, an)}的数据
41
int main() {
42
    std::vector<std::vector<double> > a;
43
    int n;
44
  std::cin >> n;
45
    a.assign(row, vector<double>());
46
    for (int i = 0; i < row; i++) {
47
        a.at(i).assign(col, 0);
48
    }
49
  for (int i = 0; i < n; i++) {
50
    std::cin >> a[i][n];
51
  }
52
  for (int i = 0; i < n; i++) {
53
    for (int j = 0; j < n; j++) {
54
      a[i][j] = pow(i + 1, n - (j + 1));
55
    }
56
  }
57
    // 高斯消元
58
  gauss_elimination(a, n);
59
    // 多项式输出
60
  fxformatprint(a, n);
61
  return 0;
62
}

1
const int CardTypeCount = 13;
2
enum CardType {
3
  Single,
4
  Double,
5
  Triple,
6
  TripleSingle,
7
  TripleDouble,
8
  Straight,
9
  DoubleStraight,
10
  TripleStraight,
11
  PlaneWithSingle,
12
  PlaneWithDouble,
13
  Bomb,
14
  SuperBomb,
15
  BombDouble,
16
};
17
std::map<std::multiset<int>, CardType> CardTypeMap{
18
  {std::multiset<int>({4}),CardType::Bomb},
19
  {std::multiset<int>({4,2}),CardType::BombDouble},
20

21
  {std::multiset<int>({3}),CardType::Triple},
22
  {std::multiset<int>({3,1}),CardType::TripleSingle},
23
  {std::multiset<int>({3,2}),CardType::TripleDouble},
24

25
  {std::multiset<int>({3,3}),CardType::TripleStraight},
26
  {std::multiset<int>({3,3,3}),CardType::TripleStraight},
27
  {std::multiset<int>({3,3,3,3}),CardType::TripleStraight},
28
  {std::multiset<int>({3,3,3,3,3}),CardType::TripleStraight},
29

30
  {std::multiset<int>({3,3,1,1}),CardType::PlaneWithSingle},
31
  {std::multiset<int>({3,3,3,1,1,1}),CardType::PlaneWithSingle},
32

33
  {std::multiset<int>({3,3,2,2}),CardType::PlaneWithDouble},
34
  {std::multiset<int>({3,3,3,2,2,2}),CardType::PlaneWithDouble},
35

36
  {std::multiset<int>({2}),CardType::Double},
37

38
  {std::multiset<int>({2,2,2}),CardType::DoubleStraight},
39
  {std::multiset<int>({2,2,2,2}),CardType::DoubleStraight},
40
  {std::multiset<int>({2,2,2,2,2}),CardType::DoubleStraight},
41
  {std::multiset<int>({2,2,2,2,2,2}),CardType::DoubleStraight},
42
  {std::multiset<int>({2,2,2,2,2,2,2}),CardType::DoubleStraight},
43
  {std::multiset<int>({2,2,2,2,2,2,2,2}),CardType::DoubleStraight},
44

45
  {std::multiset<int>({1}),CardType::Single},
46
  {std::multiset<int>({1,1}),CardType::Double},
47

48
  {std::multiset<int>({1,1,1,1,1}),CardType::Straight},
49
  {std::multiset<int>({1,1,1,1,1,1}),CardType::Straight},
50
  {std::multiset<int>({1,1,1,1,1,1,1}),CardType::Straight},
51
  {std::multiset<int>({1,1,1,1,1,1,1,1}),CardType::Straight},
52
  {std::multiset<int>({1,1,1,1,1,1,1,1,1}),CardType::Straight},
53
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
54
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
55
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
56
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
57
};
58
class CardToken {
59
private:
60
  std::string BaseString;
61
  CardType Type;
62
  template<class T>
63
  std::multiset<std::pair<int, T>> Count(std::vector<T> v) {
64
    constexpr int tmpsize = std::numeric_limits<T>::max() - std::numeric_limits<T>::min();
65
    int tmp[tmpsize];
66
    memset(tmp, 0, sizeof(tmp));
67
    for (int i = 0; i < v.size(); i++) {
68
      tmp[v[i]]++;
69
    }
70
    std::multiset<pair<int, T>> ans;
71
    for (int i = 0; i < tmpsize; i++) {
72
      if (tmp[i] != 0) {
73
        ans.insert(pair<int, T>(tmp[i], i));
74
      }
75
    }
76
    return ans;
77
  }
78
  template<class T>
79
  CardType GetCardTypeByCountResult(std::multiset<std::pair<int, T>> CountResult) {
80
    std::multiset<int> times, cards;
81
    for (typename std::multiset<std::pair<int, T>>::const_iterator iter = CountResult.begin(); iter != CountResult.end(); iter++) {
82
      times.insert(iter->first);
83
      cards.insert(iter->second);
84
    }
85
    CardType ans = CardTypeMap[times];
86
    if (ans == CardType::Double && cards.count('S') && cards.count('L')) {
87
      ans = CardType::SuperBomb;
88
    }
89
    return ans;
90
  }
91
public:
92
  CardToken(std::string BaseString) :BaseString(BaseString) {};
93
  CardToken() { BaseString = ""; }
94

95
  CardType GetCardType()const { return Type; }
96
  void SetCardType(CardType Type) {
97
    if (Type >= CardTypeCount || Type < 0) {
98
      throw "CardType undefined!";
99
    }
100
    this->Type = Type;
101
  }
102
  std::string GetBaseString()const { return BaseString; }
103
  void SetBaseString(const std::string& BaseString) {
104
    this->BaseString = BaseString;
105
    this->Type = GetCardTypeByCountResult(Count(std::vector<char>(BaseString.begin(), BaseString.end())));
106
  }
107
};
108
//3-10(X is 10),JQK,small and large king
109
//const std::string SortedCards = "3456789XJQK12SL";

1
#pragma once
2
#include <sstream>
3

4
template<class Integer>
5
class FractionBase {
6
private:
7
  inline const Integer& gcd(const Integer& a, const Integer& b) {
8
    return b > 0 ? gcd(b, a % b) : a;
9
  }
10
  inline const Integer& lcm(const Integer& a, const Integer& b) {
11
    return a * b / gcd(a, b);
12
  }
13
  inline const Integer& pow(const Integer& a, int b) {
14
    Integer result = 1;
15
    for (int i = 1; i <= b; i++) {
16
      result *= a;
17
    }
18
    return result;
19
  }
20
  inline int GetDecimalLength(double a) {
21
    std::stringstream ss;
22
    ss << a - (int)a;
23
    return ss.str().length() - 2;
24
  }
25
  inline int GetDecimalLength(long double a) {
26
    std::stringstream ss;
27
    ss << a - (int)a;
28
    return ss.str().length() - 2;
29
  }
30
  inline void Simplify() {
31

32
    Integer gcdValue = gcd(numerator, denominator);
33
    numerator /= gcdValue;
34
    denominator /= gcdValue;
35
  }
36
  Integer numerator, denominator;
37
public:
38
  FractionBase(const Integer& numerator, const Integer& denominator):
39
    numerator(numerator), denominator(denominator) {
40
    Simplify();
41
  }
42
  FractionBase(double a) {
43
    (*this) = a;
44
  }
45
  FractionBase(long double a) {
46
    (*this) = a;
47
  }
48
  FractionBase(const Integer& a) {
49
    (*this) = a;
50
  }
51
  FractionBase() { }
52
  // 获取分子
53
  Integer& GetNumerator() { return numerator; }
54
  // 获取分母
55
  Integer& GetDenominator() { return denominator; }
56
  // 获取倒数
57
  inline FractionBase GetReversed() { return FractionBase(denominator, numerator); }
58

59
  void SetNumerator(Integer numerator) {
60
    this->numerator = numerator;
61
  }
62
  void SetDenominator(Integer deno) {
63
    if (deno == 0) {
64
      throw "The denominator cannot be 0!";
65
    }
66
    denominator = deno;
67
    //std::cout << denominator << ' ' << deno << std::endl;
68
  }
69

70
  FractionBase& operator=(FractionBase a) {
71
    numerator = a.numerator;
72
    denominator = a.denominator;
73
    Simplify();
74
    return *this;
75
  }
76
  FractionBase& operator=(const Integer& a) {
77
    SetNumerator(a);
78
    SetDenominator(1);
79
    Simplify();
80
    return *this;
81
  }
82
  FractionBase& operator=(double a) {
83
    int DecimalLength = GetDecimalLength(a);
84
    SetNumerator(a * pow(10, DecimalLength));
85
    SetDenominator(pow(10, DecimalLength));
86
    Simplify();
87
    return *this;
88
  }
89
  FractionBase& operator=(long double a) {
90
    int DecimalLength = GetDecimalLength(a);
91
    SetNumerator(a * pow(10, DecimalLength));
92
    SetDenominator(pow(10, DecimalLength));
93
    Simplify();
94
    return *this;
95
  }
96

97
  friend FractionBase operator+(FractionBase& a, FractionBase& b) {
98
    return FractionBase(a.GetNumerator() * b.GetDenominator() + a.GetDenominator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
99
  }
100
  friend FractionBase operator-(FractionBase& a, FractionBase& b) {
101
    return FractionBase(a.GetNumerator() * b.GetDenominator() - a.GetDenominator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
102
  }
103
  friend FractionBase operator*(FractionBase& a, FractionBase& b) {
104
    return FractionBase(a.GetNumerator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
105
  }
106
  friend FractionBase operator/(FractionBase& a, FractionBase& b) {
107
    return a * b.GetReversed();
108
  }
109
  friend FractionBase& operator+=(FractionBase& a, const FractionBase& b) { return a = a + b; }
110
  friend FractionBase& operator-=(FractionBase& a, const FractionBase& b) { return a = a - b; }
111
  friend FractionBase& operator*=(FractionBase& a, const FractionBase& b) { return a = a * b; }
112
  friend FractionBase& operator/=(FractionBase& a, const FractionBase& b) { return a = a / b; }
113

114
  friend bool operator>(const FractionBase& a, const FractionBase& b) {
115
    return a.GetNumerator() * b.GetDenominator() > a.GetDenominator() * b.GetNumerator();
116
  }
117
  friend bool operator<(const FractionBase& a, const FractionBase& b) {
118
    return a.GetNumerator() * b.GetDenominator() < a.GetDenominator() * b.GetNumerator();
119
  }
120
  friend bool operator==(const FractionBase& a, const FractionBase& b) {
121
    return a.GetNumerator() == b.GetNumerator() && a.GetDenominator() == b.GetDenominator();
122
  }
123
  friend bool operator>=(const FractionBase& a, const FractionBase& b) {
124
    return a > b || a == b;
125
  }
126
  friend bool operator<=(const FractionBase& a, const FractionBase& b) {
127
    return a < b || a == b;
128
  }
129
  friend bool operator!=(const FractionBase& a, const FractionBase& b) {
130
    return !(a == b);
131
  }
132

133
  template<class T>
134
  friend std::ostream& operator<<(std::ostream& os, FractionBase<T> a);
135
  template<class T>
136
  friend std::istream& operator>>(std::istream& is, FractionBase<T>& a);
137
};
138

139
template<class Integer>
140
std::ostream& operator<<(std::ostream& os, FractionBase<Integer> a) {
141
  return os << a.GetNumerator() << '/' << a.GetDenominator();
142
}
143
template<class Integer>
144
std::istream& operator>>(std::istream& is, FractionBase<Integer>& a) {
145
  Integer numerator, denominator;
146
  is >> numerator >> denominator;
147
  a.SetNumerator(numerator);
148
  a.SetDenominator(denominator);
149
  return is;
150
}
151

152
typedef FractionBase<int> frac;

1
#pragma once
2
#include <functional>
3
#include <ctime>
4

5
class Random
6
{
7
private:
8
  int MTindex;
9
  long long MT[624];
10
  void csrand(int seed) {
11
    MTindex = 0;
12
    MT[0] = seed;
13
    for (int i = 1; i < 624; i++) {
14
      int t = 1812433253 * (MT[i - 1] ^ (MT[i - 1] >> 30)) + i;
15
      MT[i] = t & 0xffffffff;
16
    }
17
  }
18
  inline void generate() {
19
    for (int i = 0; i < 624; i++) {
20
      long long y = (MT[i] & 0x80000000) + (MT[(i + 1) % 624] & 0x7fffffff);
21
      MT[i] = MT[(i + 397) % 624] ^ (y >> 1);
22
      if (y % 2 == 1) MT[i] ^= 2147483647;
23
    }
24
  }
25
public:
26
  std::function<int()> RandInt = [this] {
27
    if (MTindex == 0) generate();
28
    int y = MT[MTindex];
29
    y = y ^ (y >> 11);
30
    y = y ^ ((y << 7) & 1636928640);
31
    y = y ^ ((y << 15) & 1022730752);
32
    y = y ^ (y >> 18);
33
    MTindex = (MTindex + 1) % 624;
34
    return y;
35
  };
36
  std::function<int(int, int)> RandIntEx = [this](int Min, int Max) {
37
    if (Min > Max) Min = Max;
38
    if (Min == Max) return Min;
39
    else return RandInt() % (Max - Min + 1) + Min;
40
  };
41
  std::function<long long()> RandLongLong = [this] {
42
    return ((long long)(RandInt()) << 31) + RandInt();
43
  };
44
  std::function<long long(long long, long long)> RandLongLongEx = [this](long long Min, long long Max) {
45
    if (Min > Max) Min = Max;
46
    if (Min == Max) return Min;
47
    else return RandLongLong() % (Max - Min + 1) + Min;
48
  };
49
  std::function<bool()> RandBool = [this] {
50
    return RandIntEx(0, 1);
51
  };
52
  std::function<char()> RandVisibleChar = [this] {
53
    return RandIntEx(32, 126);
54
  };
55
  std::function<char()> RandUpperLetter = [this] {
56
    return RandIntEx('A', 'Z');
57
  };
58
  std::function<char()> RandLowerLetter = [this] {
59
    return RandIntEx('a', 'z');
60
  };
61
  std::function<char()> RandLetter = [this] {
62
    return RandBool() ? RandUpperLetter() : RandLowerLetter();
63
  };
64
  std::function<char()> RandFormatChar = [this] {
65
    const char fmtc[5] = { '\n','\t','\r','\v','\f' };
66
    return fmtc[RandIntEx(0, 4)];
67
  };
68
  std::function<std::string(int)> RandWord = [this](int Length) {
69
    std::string result = "";
70
    for (int i = 0; i < Length; i++) {
71
      result = result + RandLetter();
72
    }
73
    return result;
74
  };
75
  std::function<std::string(int, int, int)> RandArticle = [this](int WordSum, int WordLengthMin = 1, int WordLengthMax = 10) {
76
    std::string result;
77
    result = RandWord(RandIntEx(WordLengthMin, WordLengthMax));
78
    for (int i = 1; i < WordSum; i++) {
79
      result = result + " " + RandWord(RandIntEx(WordLengthMin, WordLengthMax));
80
    }
81
    return result;
82
  };
83

84
  Random() {
85
    csrand((int)time(NULL));
86
  }
87
  ~Random() {
88

89
  }
90
};