Giải pháp thiết kế văn phòng hackerrank python

Cho một số đoạn đầu vào và mỗi đoạn có 2 ô ở hai bên đường. Tìm tất cả các cách có thể để xây dựng các tòa nhà trong các lô đất sao cho có một khoảng trống giữa 2 tòa nhà bất kỳ

Ví dụ.  

N = 1
Output = 4
Place a building on one side.
Place a building on other side
Do not place any building.
Place a building on both sides.

N = 3 
Output = 25
3 sections, which means possible ways for one side are 
BSS, BSB, SSS, SBS, SSB where B represents a building 
and S represents an empty space
Total possible ways are 25, because a way to place on 
one side can correspond to any of 5 ways on other side.

N = 4 
Output = 64

https. //luyện tập. chuyên viên máy tính. org/problems/count-how-possible-to-build-buildings5007/1

Chúng tôi thực sự khuyên bạn nên thu nhỏ trình duyệt của mình và tự mình thử tính năng này trước
Chúng tôi có thể đơn giản hóa vấn đề để trước tiên chỉ tính toán cho một bên. Nếu biết kết quả của một cạnh, chúng ta luôn có thể thực hiện bình phương của kết quả và nhận được kết quả cho hai bên.

Một tòa nhà mới có thể được đặt trên một phần nếu phần ngay trước khi nó có không gian. Một khoảng trống có thể được đặt ở bất cứ đâu [không quan trọng phần trước đó có tòa nhà hay không]

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

Dưới đây là triển khai ý tưởng trên.  

C++

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

18

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

19

________ 620 ________ 621 ________ 10

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

3

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

5

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____18

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____120

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

21

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

24

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____127

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____129

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____231

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____233

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____235

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____12

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

38

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____320

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____322

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7__

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

24

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

27

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

31

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

33

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

35

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

37

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6181

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6183

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

186

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6188

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____123

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

191

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

193

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

195

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____12

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

199

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6201____6202

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

203

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

204

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

205

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

206

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

207

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____123

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

210

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

Java

________ 6212 ________ 6213

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

215

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

216

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____11

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

01

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

3

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

5

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

8

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

12____113

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

14

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

17

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

18

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

27

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

29

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

31

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

33

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

35

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

34

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

13

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

36

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

13

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

38

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

24

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

48

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

49

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

50

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

31

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

33

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

35

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

37

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

_______122____6181

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____6183

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

186

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____6188

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

191

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

 

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

01

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

83

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

84

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

89

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

90

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

93____6202

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

95

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

206

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

97____198

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

 

_______439____1202

Python3

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

203

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

204

 

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

205

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

206

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

207

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

208

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1210

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

213

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

13

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

217

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____1219

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

221

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

17

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1226

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1228

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1230

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1232

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1234

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1236

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1238

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1240

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1242

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1244

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

13

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1248

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

13

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1252

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1254

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1256

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7_______324

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

259

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

260

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

261

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

49

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

264

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

265

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

13

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

217

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

270

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

244

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

274

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

248

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

248

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

270

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

265

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

274

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

244

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

274

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1289

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1291

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1293

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____1295____1214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

248

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

265

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

244

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2301

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2303

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____123

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

306____2307

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

308

 

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

309

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

311

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

314

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

315

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2317

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

90

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2321

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

323

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

324

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

326____2327

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

328

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

330

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

331

C#

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

332

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

333

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

334

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

336

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

215

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

338

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2341

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2343

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

01

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

3

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

5

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

8

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

21

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

359

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

361

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

364

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

367

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2369

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2371

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2373

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

375

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

377

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2379

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2381

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2384

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

386

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

389

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

391

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

394

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

396

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____2398

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____3200

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

24

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

205

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

31

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

33

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

215

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

216

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

15

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

37

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____3223

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____3225

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____6183

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

186

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____3233

_______122____3235

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____3237

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

240

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3244

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

01

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

83

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

249

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

199

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22____3256

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

260

PHP

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

261

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

262

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

263

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

341

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

343

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

266

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

3____3268

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

14

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____18

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

20

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

268

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

278

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

359

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

361

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

364

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2367

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3290

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3292

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3294

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3296

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3298

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____233

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2384

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2386

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4306

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

307

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

308

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

307

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4311

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

313

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2394

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2396

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____2398

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3200

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7__

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

24

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

326

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

327

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

326

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

329

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

268

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

326

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

333

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

311

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

306

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

313

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

308

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

308

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

311

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

265

_______4351____4313

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

306

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

313

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4362

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4364

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4366

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4368

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4370

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

214

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

308

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

265

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

306

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

91

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4377

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4379

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____123

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

25____4370

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

307

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

370

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

386

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3244

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____3268

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

392

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4394

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

202

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

326

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

268

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

398

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

326____6206

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1801

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

268

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

386

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1804

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1805

Javascript

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1806

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1807

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1808

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

266

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1811

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____18

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____120

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

21

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

359

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

361

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

23

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

24

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1826

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____127

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____129

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____231

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____233

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1826

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____235

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____61839

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1826

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____320

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____322

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____324

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1847

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

6

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

31

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

33

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1826

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

35

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

22

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

37

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____439

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1826

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____61863

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____61865

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____6183

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____61869

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1826

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4377

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____4379

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7____123

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

191

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

39

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1879

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

199

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1881____6202

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1883

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1884

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

206

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1886

 

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1887

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

7

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

1889

Đầu ra

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Độ phức tạp về thời gian. O[N]
Không gian phụ. Ô[1]

Mô hình thuật toán. Lập trình năng động

Một cách suy nghĩ khác. [chỉ ở một bên vì đối với bên kia, nó sẽ giống nhau]

Chúng ta hãy nghĩ về các tòa nhà như một chuỗi gồm N [vì có N ô ở hai bên] chuỗi nhị phân có độ dài [mỗi chữ số là 0 hoặc 1] trong đó

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

3

Bây giờ, khi vấn đề nêu rõ, chúng ta phải tìm số cách sao cho chúng ta không có các Tòa nhà liên tiếp trên các ô, trong chuỗi nhị phân, nó có thể được hiểu là, chúng ta cần tìm số cách mà chúng ta không có

Ví dụ

Let countB[i] be count of possible ways with i sections
              ending with a building.
    countS[i] be count of possible ways with i sections
              ending with a space.

// A space can be added after a building or after a space.
countS[N] = countB[N-1] + countS[N-1]

// A building can only be added after a space.
countB[N] = countS[N-1]

// Result for one side is sum of the above two counts.
result1[N] = countS[N] + countB[N]

// Result for two sides is square of result1[N]
result2[N] = result1[N] * result1[N] 

2

Vì vậy, bây giờ vấn đề của chúng ta được giảm xuống để tìm số cách biểu diễn chuỗi nhị phân có độ dài N sao cho nó không có số 1 liên tiếp, đây là một vấn đề khá chuẩn