1002: [FJOI2007]轮状病毒
Time Limit: 1 Sec Memory Limit: 162 MB
Submit: 3928 Solved: 2154
[Submit][Status][Discuss]
Description
轮状病毒有很多变种，所有轮状病毒的变种都是从一个轮状基产生的。一个N轮状基由圆环上N个不同的基原子
和圆心处一个核原子构成的，2个原子之间的边表示这2个原子之间的信息通道。如下图所示
N轮状病毒的产生规律是在一个N轮状基中删去若干条边，使得各原子之间有唯一的信息通道，例如共有16个不
同的3轮状病毒，如下图所示
现给定n(N<=100)，编程计算有多少个不同的n轮状病毒
Input
第一行有1个正整数n
Output
计算出的不同的n轮状病毒数输出
Sample Input
3
Sample Output
16
纯属娱乐~~~
#ifndef EXTINT_H
#define EXTINT_H #include <cctype>
#include <string>
#include <istream>
#include <ostream>
#include <cassert>
#include <iomanip>
#include <iostream> class ExtInt{
friend ExtInt operator +(const ExtInt &a, const ExtInt &b);
friend ExtInt operator -(const ExtInt &a, const ExtInt &b);
friend ExtInt operator *(const ExtInt &a, const ExtInt &b);
friend ExtInt operator /(const ExtInt &a, const ExtInt &b);
friend ExtInt operator %(const ExtInt &a, const ExtInt &b);
friend bool operator <(const ExtInt &a, const ExtInt &b);
friend bool operator >(const ExtInt &a, const ExtInt &b);
friend bool operator <=(const ExtInt &a, const ExtInt &b);
friend bool operator >=(const ExtInt &a, const ExtInt &b);
friend bool operator ==(const ExtInt &a, const ExtInt &b);
friend bool operator !=(const ExtInt &a, const ExtInt &b);
friend std::istream & operator >>(std::istream &inputStream, ExtInt &data);
friend std::ostream & operator <<(std::ostream &outputStream, const ExtInt &data);
private:
static const int LIMIT = ;
static const int WIDTH = ;
int length;
bool isNegative;
struct DListNode{
int data;
DListNode *forward, *next;
DListNode(int data = ) : data(data), forward(NULL), next(NULL) {}
DListNode & remove();
DListNode & append(DListNode *data);
DListNode & append(const int &data);
DListNode & insert(DListNode *data);
DListNode & insert(const int &data);
}*low, *high;
public:
ExtInt(int data = );
ExtInt(const ExtInt &rhs);
ExtInt(const std::string &rhs);
virtual ~ExtInt(); ExtInt & operator =(const ExtInt &rhs);
ExtInt & operator +=(const ExtInt &rhs);
ExtInt & operator -=(const ExtInt &rhs);
ExtInt & operator *=(const ExtInt &rhs);
ExtInt & operator /=(const ExtInt &rhs);
ExtInt & operator %=(const ExtInt &rhs);
//ExtInt & operator ++();
//ExtInt & operator ++(int);
//ExtInt & operator --();
//ExtInt & operator --(int);
}; #endif ExtInt::DListNode & ExtInt::DListNode::remove() {
DListNode *tmp = this -> forward;
tmp -> forward -> next = this;
this -> forward = tmp -> forward;
delete tmp;
return *this;
}
ExtInt::DListNode & ExtInt::DListNode::append(DListNode *data) {
data -> next = this -> next;
data -> forward = this;
if (this -> next != NULL) {
this -> next -> forward = data;
}
this -> next = data;
return *this;
}
ExtInt::DListNode & ExtInt::DListNode::append(const int &data) {
return append(new DListNode(data));
}
ExtInt::DListNode & ExtInt::DListNode::insert(DListNode *data) {
data -> next = this;
data -> forward = this -> forward;
if (this -> forward != NULL) {
this -> forward -> next = data;
}
this -> forward = data;
return *this;
}
ExtInt::DListNode & ExtInt::DListNode::insert(const int &data) {
return insert(new DListNode(data));
} ExtInt::ExtInt(int data) {
low = new DListNode;
high = new DListNode;
low -> append(high);
length = ;
isNegative = false;
if (data < ) {
isNegative = true;
data = -data;
}
while (data >= ExtInt::LIMIT) {
high -> insert(data % ExtInt::LIMIT);
data /= ExtInt::LIMIT;
length++;
}
if (length == || data > ) {
high -> insert(data);
length++;
}
}
ExtInt::ExtInt(const ExtInt &rhs) {
low = new DListNode;
high = new DListNode;
low -> append(high);
length = ;
isNegative = rhs.isNegative;
for (DListNode *it = rhs.low -> next; it != rhs.high; it = it -> next) {
high -> insert(it -> data);
length++;
}
}
ExtInt::ExtInt(const std::string &rhs) {
low = new DListNode;
high = new DListNode;
low -> append(high);
length = ;
isNegative = false;
if (rhs[] == '-') {
isNegative = true;
}
for (int i = rhs.length() - ; i >= ; i -= WIDTH) {
int value = ;
for (int j = std::max(, i - WIDTH + ); j <= i; j++) {
if (j == && isNegative) continue;
assert(isdigit(rhs[j]));
value = value * + rhs[j] - '';
}
high -> insert(value);
length++;
}
while (length > && high -> forward -> data == ) {
high -> remove();
length--;
}
}
ExtInt & ExtInt::operator =(const ExtInt &rhs) {
if (this == &rhs) return *this;
if (low != NULL || high != NULL) {
this -> ~ExtInt();
}
low = new DListNode;
high = new DListNode;
low -> append(high);
length = ;
isNegative = rhs.isNegative;
for (DListNode *it = rhs.low -> next; it != rhs.high; it = it -> next) {
high -> insert(it -> data);
length++;
}
return *this;
}
ExtInt::~ExtInt() {
for (DListNode *it = low; it != NULL;) {
DListNode *tmp = it -> next;
delete it;
it = tmp;
}
} std::istream & operator >>(std::istream &inputStream, ExtInt &data) {
std::string tmp;
inputStream >> tmp;
data = ExtInt(tmp);
return inputStream;
}
std::ostream & operator <<(std::ostream &outputStream, const ExtInt &data) {
if (data.isNegative) {
outputStream << "-";
}
ExtInt::DListNode *it = data.high -> forward;
outputStream << it -> data;
for (it = it -> forward; it != data.low; it = it -> forward) {
outputStream << std::setfill('') << std::setw(ExtInt::WIDTH) << it -> data;
}
return outputStream;
} bool operator <(const ExtInt &a, const ExtInt &b) {
if (a.isNegative && !b.isNegative) return true;
if (!a.isNegative && b.isNegative) return false;
bool flag = false;
if (a.isNegative && b.isNegative) flag = true;
if (a.length < b.length) return flag ^ true;
if (a.length > b.length) return flag ^ false;
ExtInt::DListNode *itA = a.high, *itB = b.high;
for (; itA != a.low && itB != b.low; itA = itA -> forward, itB = itB -> forward) {
if (itA -> data < itB -> data) return flag ^ true;
if (itA -> data > itB -> data) return flag ^ false;
}
return false;
}
bool operator >(const ExtInt &a, const ExtInt &b) {
if (a.isNegative && !b.isNegative) return false;
if (!a.isNegative && b.isNegative) return true;
bool flag = false;
if (a.isNegative && b.isNegative) flag = true;
if (a.length < b.length) return flag ^ false;
if (a.length > b.length) return flag ^ true;
ExtInt::DListNode *itA = a.high, *itB = b.high;
for (; itA != a.low && itB != b.low; itA = itA -> forward, itB = itB -> forward) {
if (itA -> data < itB -> data) return flag ^ false;
if (itA -> data > itB -> data) return flag ^ true;
}
return false;
}
bool operator >=(const ExtInt &a, const ExtInt &b) {
return !(a < b);
}
bool operator <=(const ExtInt &a, const ExtInt &b) {
return !(a > b);
}
bool operator ==(const ExtInt &a, const ExtInt &b) {
if (a.isNegative != b.isNegative) return false;
if (a.length != b.length) return false;
ExtInt::DListNode *itA = a.low, *itB = b.low;
for (; itA != a.high && itB != b.high; itA = itA -> next, itB = itB -> next) {
if (itA -> data != itB -> data) return false;
}
return true;
}
bool operator !=(const ExtInt &a, const ExtInt &b) {
return !(a == b);
} ExtInt operator +(const ExtInt &a, const ExtInt &b) {
if (b.isNegative) {
ExtInt tmp = b;
tmp.isNegative = false;
return a - tmp;
}
if (a.isNegative) {
ExtInt tmp = a;
tmp.isNegative = false;
return b - tmp;
}
ExtInt ret = a;
ExtInt::DListNode *itA = ret.low -> next, *itB = b.low -> next;
for (; itB != b.high; itA = itA -> next, itB = itB -> next) {
if (itA == ret.high) {
itA -> insert();
ret.length++;
itA = itA -> forward;
}
itA -> data += itB -> data;
if (itA -> data >= ExtInt::LIMIT) {
if (itA -> next == ret.high) {
itA -> append();
ret.length++;
}
itA -> next -> data += itA -> data / ExtInt::LIMIT;
itA -> data %= ExtInt::LIMIT;
}
}
return ret;
}
ExtInt operator -(const ExtInt &a, const ExtInt &b) {
if (b.isNegative) {
ExtInt tmp = b;
tmp.isNegative = false;
return a + tmp;
}
if (a.isNegative) {
ExtInt tmp = a;
tmp.isNegative = false;
tmp = tmp + b;
tmp.isNegative = true;
return tmp;
}
if (a < b) {
ExtInt tmp = b - a;
tmp.isNegative = true;
return tmp;
}
ExtInt ret = a;
ExtInt::DListNode *itA = ret.low -> next, *itB = b.low -> next;
for (; itA != ret.high && itB != b.high; itA = itA -> next, itB = itB -> next) {
itA -> data -= itB -> data;
if (itA -> data < ) {
itA -> data += ExtInt::LIMIT;
itA -> next -> data--;
}
}
for (; itA != ret.high; itA = itA -> next) {
if (itA -> data < ) {
itA -> data += ExtInt::LIMIT;
itA -> next -> data--;
}
}
while (ret.length > && ret.high -> forward -> data == ) {
ret.high -> remove();
ret.length--;
}
return ret;
}
ExtInt operator *(const ExtInt &a, const ExtInt &b) {
if (a == ExtInt() || b == ExtInt()) return ExtInt();
ExtInt ret, tmp;
ExtInt::DListNode *itB = b.low -> next;
for (int value = ; itB != b.high; itB = itB -> next, value++) {
if (itB -> data == ) {
continue;
}
tmp = a;
ExtInt::DListNode *itA = tmp.low -> next;
for (long long r = ; itA != tmp.high; itA = itA -> next) {
long long now = 1ll * itA -> data * itB -> data + r;
itA -> data = now % ExtInt::LIMIT;
r = ;
if (now >= ExtInt::LIMIT) {
if (itA -> next == tmp.high) {
itA -> append();
tmp.length++;
}
r = now / ExtInt::LIMIT;
}
}
for (int i = ; i <= value; i++) {
tmp.low -> append();
tmp.length++;
}
//std::cerr << ret << std::endl;
//std::cerr << tmp << std::endl;
//std::cerr << tmp.length << std::endl;
ret = ret + tmp;
}
ret.isNegative = a.isNegative ^ b.isNegative;
return ret;
}
ExtInt operator /(const ExtInt &a, const ExtInt &b) {
assert(b != ExtInt());
if (a == ExtInt()) return ExtInt();
ExtInt ret, tmp, div = b;
ret.high -> remove();
ret.length = ;
tmp.high -> remove();
tmp.length = ;
div.isNegative = false;
ExtInt::DListNode *itA = a.high -> forward;
for (; itA != a.low; itA = itA -> forward) {
tmp.low -> append(itA -> data);
tmp.length++;
if (tmp >= div) {
int left = , right = ExtInt::LIMIT - ;
while (left < right) {
int middle = (left + right >> ) + ;
if (tmp >= div * middle) {
left = middle;
} else {
right = middle - ;
}
}
//std::cerr << tmp << " " << div * left << std::endl;
ret.low -> append(left);
ret.length++;
tmp = tmp - div * left;
} else {
ret.low -> append();
ret.length++;
}
if (tmp == ExtInt()) {
tmp.high -> remove();
tmp.length = ;
}
}
while (ret.length > && ret.high -> forward -> data == ) {
ret.high -> remove();
ret.length--;
}
ret.isNegative = a.isNegative ^ b.isNegative;
if (ret.isNegative && tmp.low -> next != tmp.high) {
ret = ret - ;
}
return ret;
}
ExtInt operator %(const ExtInt &a, const ExtInt &b) {
return a - a / b * b;
} ExtInt & ExtInt::operator +=(const ExtInt &rhs) {
*this = *this + rhs;
return *this;
}
ExtInt & ExtInt::operator -=(const ExtInt &rhs) {
*this = *this - rhs;
return *this;
}
ExtInt & ExtInt::operator *=(const ExtInt &rhs) {
*this = *this * rhs;
return *this;
}
ExtInt & ExtInt::operator /=(const ExtInt &rhs) {
*this = *this / rhs;
return *this;
}
ExtInt & ExtInt::operator %=(const ExtInt &rhs) {
*this = *this % rhs;
return *this;
}
#include <iostream>
#include <cstdio>
using namespace std;
int n;
const int maxn=;
ExtInt C[maxn][maxn];
void abs(ExtInt &x){
if(x<)x=x*(-);
}
void Solve(){
for(int i=;i<n;i++){
for(int j=i+;j<n;j++)
while(C[j][i]!=){
ExtInt r=C[i][i]/C[j][i];
for(int k=i;k<n;k++)
C[i][k]-=C[j][k]*r;
swap(C[i],C[j]);
}
}
ExtInt ans=;
for(int i=;i<n;i++)
ans*=C[i][i];
abs(ans);
cout<<ans<<endl;
return;
}
int main(){
scanf("%d",&n);n++;
if(n!=)
for(int i=;i<n;i++){
C[i][i%(n-)+]-=;
C[i%(n-)+][i]-=;C[i][i]+=;
C[i%(n-)+][i%(n-)+]+=;
}
for(int i=;i<n;i++){
C[i][n]=-;
C[n][i]=-;
C[i][i]+=;
C[n][n]+=;
}
Solve();
return ;
}