# Question

There is a fence with n posts, each post can be painted with one of the k colors.

You have to paint all the posts such that no more than two adjacent fence posts have the same color.

Return the total number of ways you can paint the fence.

Note: n and k are non-negative integers.

Example:

```
Input: n = 3, k = 2
Output: 6
Explanation: Take c1 as color 1, c2 as color 2. All possible ways are:
post1 post2 post3
----- ----- ----- -----
1 c1 c1 c2
2 c1 c2 c1
3 c1 c2 c2
4 c2 c1 c1
5 c2 c1 c2
6 c2 c2 c1
```

# Solution

If `n == 1`

, there would be `k`

-ways to paint.

if `n == 2`

, there would be two situations:

- 2.1 You paint same color with the previous post:
`k*1`

ways to paint, named it as`same`

; - 2.2 You paint differently with the previous post:
`k*(k-1)`

ways to paint this way, named it as`diff`

.

So, you can think, if `n >= 3`

, you can always maintain these two situations, You either paint the same color with the previous one, or differently.

Since there is a rule: “no more than two adjacent fence posts have the same color.”

We can further analyze:

- from 2.1, since previous two are in the same color, next one you could only paint differently, and it would form one part of “paint differently” case in the
`n == 3`

level, and the number of ways to paint this way would equal to`same*(k-1)`

. - from 2.2, since previous two are not the same, you can either paint the same color this time (
`diff*1`

) ways to do so, or stick to paint differently (`diff*(k-1)`

) times.

Here you can conclude, when seeing back from the next level, ways to paint the same, or variable `same`

would equal to `diff*1 = diff`

, and ways to paint differently, variable `diff`

, would equal to `same * (k - 1) + diff * (k - 1) = (same + diff) * (k - 1)`

.

```
class Solution(object):
def numWays(self, n, k):
"""
:type n: int
:type k: int
:rtype: int
"""
if k == 0 or n == 0:
return 0
if n == 1:
return k
same = k
diff = k * (k - 1)
for _ in range(3, n + 1):
same, diff = diff, (same + diff) * (k - 1)
return same + diff
```