生成括號

原題

　　Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
　　For example, given n = 3, a solution set is:

"((()))", "(()())", "(())()", "()(())", "()()()"

• 1

• 1

 

題目大意

　　給定n對括號，輸出他們全部正確的組合

解題思路

　　採用遞歸求解試

代碼實現

算法實現類

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * Author: 王俊超
 * Date: 2015-06-22
 * Time: 11:13
 * Declaration: All Rights Reserved !!!
 */
public class Solution {
    public List<String> generateParenthesis(int n) {
        // 保存結果的隊列
        List<String> result = new ArrayList<>();
        // 括號數大於0
        if (n > 0) {
            // 捛使用數組
            char[] parentheses = new char[2 * n];
            // 問題求解
            solve(n, n, parentheses, result);
        }
        return result;
    }

    /**
     * @param left        剩餘可用的左括號數
     * @param right       剩餘可用的右括號數
     * @param parentheses 到上一次爲止括號使用的狀況
     * @param result      存放結果的集合
     */
    public void solve(int left, int right, char[] parentheses, List<String> result) {

        // 剩下的括號數不能小於0，而且每次剩下的右括號數都不能小於左括號數
        if (left < 0 || right < 0 || right < left) {
            // 什麼都不用作
        }
        // 左右括號都被使用完了
        else if (left == 0 && right == 0) {
            result.add(new String(parentheses));
        }
        // 能夠使用
        else {
            // 當前使用的位置
            int idx = parentheses.length - left - right;
            // 使用左括號
            parentheses[idx] = '(';
            // 遞歸求解
            solve(left - 1, right, parentheses, result);
            // 使用右括號
            parentheses[idx] = ')';
            solve(left, right - 1, parentheses, result);
        }
    }
}

 

描述

如今，有一行括號序列，請你檢查這行括號是否配對。

輸入

第一行輸入一個數N（0<N<=100）,表示有N組測試數據。後面的N行輸入多組輸入數據，每組輸入數據都是一個字符串S(S的長度小於10000，且S不是空串），測試數據組數少於5組。數據保證S中只含有"[","]","(",")"四種字符

輸出

每組輸入數據的輸出佔一行，若是該字符串中所含的括號是配對的，則輸出Yes,若是不配對則輸出No

樣例輸入

3
[(])
(])
([[]()])

樣例輸出

 

No
No
Yes

 

 

 

 

[java] view plain copy

 

1. import java.util.Scanner;  
2. import java.util.Stack;  
3.   
4. /** 
5.  * @author Owner 
6.  *  
7.  */  
8. public class Main {  
9.   
10.     public static void main(String[] args) {  
11.         Scanner sc = new Scanner(System.in);  
12.           
13.         int n= sc.nextInt();//3條測試數據數據  
14.           
15.         Stack<Character> stack = null;  
16.           
17.         while(n!=0){  
18.               
19.             //從控制檯讀入一個測試字符串[]() [(])  
20.             String str = sc.next();  
21.             //若是該輸入字符串爲奇數，說明不匹配  
22.             if(str.length() % 2 == 1){  
23.                 System.out.println("No");  
24.             }else{  
25.                 //說明字符是偶數  
26.                 stack = new Stack<Character>();  
27.                   
28.                 //遍歷第一條測試字符串[]() [(])  
29.                 for(int i=0;i<str.length();i++){  
30.                     if(stack.isEmpty()){  
31.                         //若是棧是空的  
32.                         stack.push(str.charAt(i));  
33.                     }else if(stack.peek() == '[' && str.charAt(i) == ']' || stack.peek() == '(' && str.charAt(i) == ')'){  
34.                         //說明此時棧中字符不是空的,而且符合，  
35.                         stack.pop();  
36.                     }else{  
37.                           
38.                         stack.push(str.charAt(i));  
39.                     }  
40.                 }  
41.                   
42.                 if(stack.isEmpty()){  
43.                     //若是棧是空的，說明括號匹配  
44.                     System.out.println("Yes");  
45.                 }else{  
46.                     //說明棧不爲空，括號不匹配  
47.                     System.out.println("No");  
48.                 }  
49.             }  
50.               
51.             n--;  
52.         }  
53.           
54.     }  
55. } 

根據題意分析。咱們先取n=3.畫出全部的狀況。

代碼

[java] view plain copy

print?

1. package parenthesis;  
2.   
3. public class Parenthesis {  
4.   
5.     static void printParenthesis(int pos , int n , int open ,int close ,char[] buffer){  
6.         //System.out.println("step"+pos+" open is : "+ open + "close is :" + close);  
7.         //System.out.println(new String(buffer));  
8.         if(close == n){  
9.             //System.out.println("over");  
10.             System.out.println(new String(buffer));  
11.               
12.             return;  
13.         }  
14.         if(open >close){  
15.             buffer[pos]='}';  
16.             printParenthesis(pos+1, n, open, close+1, buffer);  
17.               
18.         }  
19.           
20.         if(open <n){  
21.             buffer[pos] = '{';  
22.             printParenthesis(pos+1, n, open+1, close, buffer);  
23.         }  
24.           
25.     }  
26.     public static void main(String[] args) {  
27.         // TODO Auto-generated method stub  
28.         //System.out.println("012142");  
29.         int  n = 4;  
30.         char[] cs = new char[8];  
31.         printParenthesis(0, 4, 0, 0, cs);  
32.         //System.out.println("012143");  
33.     }  
34.   
35. }