int main(void)
{
	int n, i;
	int * a;
	int catalan[20] = { 0 };//第20个超出int范围,就不用long long了,反正很快又会超范围的O(∩_∩)O!
	Catalan(catalan);
	SeqStack * S;
	S = (SeqStack *)malloc(sizeof(SeqStack));
	printf("请输入堆栈个数(0结束)");
	while (scanf("%d", &n) && n > 0)
	{
		memset(S->flag, 0, sizeof(S->flag));
		S->num = n;
		S->stack = (int **)calloc(catalan[n], sizeof(int *));//分配二维数组
		for (i = 0; i < catalan[n]; i++)
		{
			S->stack[i] = (int *)calloc(n, sizeof(int));
		}
		memset(S->flag, 0, sizeof(S->flag));
		//S->top = 0;//初始化(默认第一个入栈)
		for (i = 0; i < n; i++)
		{
			scanf("%d", &S->input[i]);
		}
		a = Print(S, n - 1, 0, 0);//默认进第一个,则少一个入栈数。
		Delete(S, catalan);
		printf("请输入堆栈个数(0结束)");
		*a = -1;//静态变量a归初始化,重复使用^_^
	}
	return 0;
}
示例#2
0
int main()
{
  int i; //for 'for' loops

  //level to stop splitting
  int L, L1; //this means each state has L leaves resulting from k splits
  cout << "Number of splits? ";
  cin >> L1;
  L = L1 + 1;

  //number of splits
  int k;

  //number of distinct states or Catalan number
  long double Csplit[L];

  //total number of possible paths to reach any state at level L
  unsigned long int totalPaths[L];

  //container for states
  States currStates, nextStates;
  States::iterator iterCurrStates;
  State currState, nextState;
  State::iterator iterCurrState;

  // a map for the Catalan Coefficients
  typedef map<State, int, LexicoSorting<State> > StatesMap;
  StatesMap StateCount;
  StatesMap::iterator iterStateCount;
  std::pair<StatesMap::iterator, bool> boolStateCount;

  //state space at 0 split
  State state0;
  state0.push_back(0);

  StateCount.insert(make_pair(state0,1));

  Csplit[0]=1;
  totalPaths[0]=1;

  //ofstream to output CatalanCoefficient and CatalanFrequencies to .txt.
  ofstream oss;

  clock_t start, end;
  double timeTaken;

  //Loop to get Catalan coefficients and frequencies using L-R leaf-depth encoding
  for (k=1; k < L; k++)  //for a given number of splits
  {
    //Set up string for filename to output the Catalan coefficients and frequencies
    string fileNameCC, fileNameCF;
    fileNameCC = "CatalanCoefficientSplit";
    fileNameCF = "CatalanFrequencySplit";
    std::ostringstream stm1;  //convert k to std::ostringstream

    start=clock();  //record the time taken to get the Catalan coefficient and frequencies 

    //Get number of nodes, Catalan number and total possible paths for each split
    Csplit[k] = Catalan(k); 
    totalPaths[k] = factorial(k);
    cout << "========================================" << endl;
    cout << "At " << k << " splits:" << endl;
    cout << Csplit[k] << " distinct states " << "\t" << totalPaths[k] << " possible paths " << endl;

    //Set up an empty map to store new states
    StatesMap newStateCount;
    StatesMap::iterator iterNewStateCount;
    std::pair<StatesMap::iterator, bool> boolNewStateCount;

    //for each state in current states map, StateCount
    for (iterStateCount=StateCount.begin(); iterStateCount != StateCount.end(); iterStateCount++)
    {
      currState = iterStateCount->first;  //current state in current states map
      //cout << "Current state:" << getStringState(currState) << endl;

      //for each node in current state
      for(int node = 0; node < currState.size(); node++)
      {
	//get state for each node in current state
	nextState = getNextState(currState, node);
	//cout << "Next state: " << getStringState(nextState) << endl;

	//insert the new state into newStateMap
	boolNewStateCount = newStateCount.insert(make_pair(nextState, 1));
	//Check if insertion is successful - a unique set will render a successful insertion.
	if(!(boolNewStateCount.second)) //if state is not unique
	{
	  //increment by the Catalan coefficient of the current state producing this next state
          newStateCount[nextState] += StateCount[currState];	
	  //cout << "this state already exist"  << endl;
	}  //end of "non-unique state"
	else
	{
          //set the count of this next state as the Catalan coefficient of current state
          newStateCount[nextState] = StateCount[currState];
          //cout << "this is a unique state" << endl;
	}  //end of "unique state"
      } //end of looping over node in current state
    } //end of looping through all Ck states in current states map

    cout << "There are " << newStateCount.size() << endl;
    //cout << " distinct states with the following breakdown:" << endl; 

    //Catalan Coefficients
    //Output states with corresponding counts in .txt.
    stm1 << k; //name file according to the number of splits k
    fileNameCC += stm1.str();
    fileNameCC += ".txt";
    oss.open(fileNameCC.c_str());

    //set up a vector for the number of paths leading to each state in newStateCount
    vector<int> StatePathVec;
    vector<int>::iterator iterStatePathVec;

    //set up a map for the frequencies corresponding to state paths
    map<int, int, less<int> > StateFreqMap;
    map<int, int, less<int> >::iterator iterStateFreqMap;
    std::pair<map<int, int, less<int> >::iterator, bool> boolStateFreqMap;
    int Path;

    for(iterNewStateCount=newStateCount.begin(); 
        iterNewStateCount != newStateCount.end(); iterNewStateCount++)
    {
      State thisState = iterNewStateCount->first;
      //cout << getStringState(thisState) << "\t\t" << iterNewStateCount->second << endl;
      oss << getStringState(thisState) << "\t" << (iterNewStateCount->second)<< "\n";

      //Find frequencies for state paths
      Path = iterNewStateCount->second;
      boolStateFreqMap = StateFreqMap.insert(make_pair(Path, 1));

      if (!(boolStateFreqMap.second)) //if there is more than one state with Path
      {
        StateFreqMap[Path] += 1;
      }
    }

    //close ostream for CatalanCoefficientSplitk.txt
    oss << flush;
    oss.close();
    cout << "State counts output to " << fileNameCC << endl;


    //output Catalan Frequencies to.txt
    fileNameCF += stm1.str();
    fileNameCF += ".txt";
    oss.open(fileNameCF.c_str());
    oss << "Paths" << "\t\t" << "States" << "\n";
    //Output to .txt
    for (iterStateFreqMap = StateFreqMap.begin(); iterStateFreqMap != StateFreqMap.end(); iterStateFreqMap++)
    {
      //cout << "There are " << iterStateFreqMap->second << " states with " 
      //     << iterStateFreqMap->first << " paths." << endl;
      oss << iterStateFreqMap->first << "\t\t" << iterStateFreqMap->second << "\n";
    }

    oss << flush;
    oss.close();
    cout << "State frequencies output to " << fileNameCF << endl;


    //Empty current states map
    StateCount.clear();

    if ( StateCount.empty())
    {
      //set nextStateCount map to be StateCount to continue loop
      //cout << "space emptied" << endl;
      StateCount = newStateCount;
    }
    else
    {
      cout << "space not emptied. Should not proceed." << endl;
      break;
    }

    end=clock();
    timeTaken = static_cast<double>(end-start)/CLOCKS_PER_SEC;
    cout << "Computing time : " <<timeTaken<< " s." << endl;
  }

  return 0;
}