45
45
46
46
<!-- 这里可写通用的实现逻辑 -->
47
47
48
+ ** 方法一:动态规划**
49
+
50
+ 由于街道两侧房子的摆放互不影响,因此,我们可以只考虑一侧的摆放情况,最后将一侧的方案数平方取模得到最终结果。
51
+
52
+ 我们定义 $f[ i] $ 表示放置前 $i+1$ 个地块,且最后一个地块放置房子的方案数,定义 $g[ i] $ 表示放置前 $i+1$ 个地块,且最后一个地块不放置房子的方案数。初始时 $f[ 0] = g[ 0] = 1$。
53
+
54
+ 当我们放置第 $i+1$ 个地块时,有两种情况:
55
+
56
+ - 如果第 $i+1$ 个地块放置房子,那么第 $i$ 个地块必须不放置房子,因此方案数 $f[ i] =g[ i-1] $;
57
+ - 如果第 $i+1$ 个地块不放置房子,那么第 $i$ 个地块可以放置房子,也可以不放置房子,因此方案数 $g[ i] =f[ i-1] +g[ i-1] $。
58
+
59
+ 最终,我们将 $f[ n-1] +g[ n-1] $ 的平方取模即为答案。
60
+
61
+ 时间复杂度 $O(n)$,空间复杂度 $O(n)$。其中 $n$ 为街道的长度。
62
+
48
63
<!-- tabs:start -->
49
64
50
65
### ** Python3**
55
70
class Solution :
56
71
def countHousePlacements (self , n : int ) -> int :
57
72
mod = 10 ** 9 + 7
58
- f = [[ 0 ] * 2 for _ in range (n)]
59
- f[ 0 ] = [1 , 1 ]
73
+ f = [1 ] * n
74
+ g = [1 ] * n
60
75
for i in range (1 , n):
61
- f[i][ 0 ] = f [i - 1 ][ 0 ] + f[i - 1 ][ 1 ]
62
- f [i][ 1 ] = f[i - 1 ][ 0 ]
63
- s = sum ( f[- 1 ])
64
- return (s * s) % mod
76
+ f[i] = g [i - 1 ]
77
+ g [i] = ( f[i - 1 ] + g[i - 1 ]) % mod
78
+ v = f[- 1 ] + g[ - 1 ]
79
+ return v * v % mod
65
80
```
66
81
67
82
### ** Java**
@@ -71,15 +86,17 @@ class Solution:
71
86
``` java
72
87
class Solution {
73
88
public int countHousePlacements (int n ) {
74
- int mod = (int ) 1e9 + 7 ;
75
- long [][] f = new long [n][2 ];
76
- f[0 ] = new long [] {1 , 1 };
89
+ final int mod = (int ) 1e9 + 7 ;
90
+ int [] f = new int [n];
91
+ int [] g = new int [n];
92
+ f[0 ] = 1 ;
93
+ g[0 ] = 1 ;
77
94
for (int i = 1 ; i < n; ++ i) {
78
- f[i][ 0 ] = (f [i - 1 ][ 0 ] + f[i - 1 ][ 1 ]) % mod ;
79
- f [i][ 1 ] = f[i - 1 ][ 0 ] ;
95
+ f[i] = g [i - 1 ];
96
+ g [i] = ( f[i - 1 ] + g[i - 1 ]) % mod ;
80
97
}
81
- long s = f[n - 1 ][ 0 ] + f [n - 1 ][ 1 ] ;
82
- return (int ) ((s * s) % mod);
98
+ long v = ( f[n - 1 ] + g [n - 1 ]) % mod ;
99
+ return (int ) (v * v % mod);
83
100
}
84
101
}
85
102
```
@@ -90,15 +107,15 @@ class Solution {
90
107
class Solution {
91
108
public:
92
109
int countHousePlacements(int n) {
93
- int mod = 1e9 + 7;
94
- vector<vector< long >> f(n, vector< long >(2)) ;
95
- f[ 0] = {1, 1} ;
110
+ const int mod = 1e9 + 7;
111
+ int f [ n ] , g [ n ] ;
112
+ f[ 0] = g [ 0 ] = 1 ;
96
113
for (int i = 1; i < n; ++i) {
97
- f[ i] [ 0 ] = (f [ i - 1] [ 0 ] + f [ i - 1 ] [ 1 ] ) % mod ;
98
- f [ i] [ 1 ] = f[ i - 1] [ 0 ] ;
114
+ f[ i] = g [ i - 1] ;
115
+ g [ i] = ( f[ i - 1] + g [ i - 1 ] ) % mod ;
99
116
}
100
- long s = f[ n - 1] [ 0 ] + f [ n - 1 ] [ 1 ] ;
101
- return (int)((s * s) % mod) ;
117
+ long v = f[ n - 1] + g [ n - 1] ;
118
+ return v * v % mod;
102
119
}
103
120
};
104
121
```
@@ -107,32 +124,52 @@ public:
107
124
108
125
```go
109
126
func countHousePlacements(n int) int {
110
- mod := int(1e9) + 7
111
- f := make([][]int, n)
112
- for i := range f {
113
- f[i] = make([]int, 2)
114
- }
115
- f[0] = []int{1, 1}
127
+ const mod = 1e9 + 7
128
+ f := make([]int, n)
129
+ g := make([]int, n)
130
+ f[0], g[0] = 1, 1
116
131
for i := 1; i < n; i++ {
117
- f[i][0] = (f [i-1][0] + f[i-1][1]) % mod
118
- f [i][1] = f[i-1][0]
132
+ f[i] = g [i-1]
133
+ g [i] = ( f[i-1] + g[i-1]) % mod
119
134
}
120
- s := f[n-1][0] + f [n-1][ 1]
121
- return (s * s) % mod
135
+ v := f[n-1] + g [n-1]
136
+ return v * v % mod
122
137
}
123
138
```
124
139
125
140
### ** TypeScript**
126
141
127
142
``` ts
128
143
function countHousePlacements(n : number ): number {
144
+ const f = new Array (n );
145
+ const g = new Array (n );
146
+ f [0 ] = g [0 ] = 1n ;
129
147
const mod = BigInt (10 ** 9 + 7 );
130
- let pre = 1n ,
131
- count = 2n ;
132
- for (let i = 2 ; i <= n ; i ++ ) {
133
- [count , pre ] = [(count + pre ) % mod , count ];
148
+ for (let i = 1 ; i < n ; ++ i ) {
149
+ f [i ] = g [i - 1 ];
150
+ g [i ] = (f [i - 1 ] + g [i - 1 ]) % mod ;
151
+ }
152
+ const v = f [n - 1 ] + g [n - 1 ];
153
+ return Number (v ** 2n % mod );
154
+ }
155
+ ```
156
+
157
+ ### ** C#**
158
+
159
+ ``` cs
160
+ public class Solution {
161
+ public int CountHousePlacements (int n ) {
162
+ const int mod = (int ) 1 e 9 + 7 ;
163
+ int [] f = new int [n ];
164
+ int [] g = new int [n ];
165
+ f [0 ] = g [0 ] = 1 ;
166
+ for (int i = 1 ; i < n ; ++ i ) {
167
+ f [i ] = g [i - 1 ];
168
+ g [i ] = (f [i - 1 ] + g [i - 1 ]) % mod ;
169
+ }
170
+ long v = (f [n - 1 ] + g [n - 1 ]) % mod ;
171
+ return (int ) (v * v % mod );
134
172
}
135
- return Number (count ** 2n % mod );
136
173
}
137
174
```
138
175
0 commit comments