<p>You are given a 2D integer array <code>tiles</code> where <code>tiles[i] = [l<sub>i</sub>, r<sub>i</sub>]</code> represents that every tile <code>j</code> in the range <code>l<sub>i</sub> &lt;= j &lt;= r<sub>i</sub></code> is colored white.</p>

<p>You are also given an integer <code>carpetLen</code>, the length of a single carpet that can be placed <strong>anywhere</strong>.</p>

<p>Return <em>the <strong>maximum</strong> number of white tiles that can be covered by the carpet</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/25/example1drawio3.png" style="width: 644px; height: 158px;" />
<pre>
<strong>Input:</strong> tiles = [[1,5],[10,11],[12,18],[20,25],[30,32]], carpetLen = 10
<strong>Output:</strong> 9
<strong>Explanation:</strong> Place the carpet starting on tile 10. 
It covers 9 white tiles, so we return 9.
Note that there may be other places where the carpet covers 9 white tiles.
It can be shown that the carpet cannot cover more than 9 white tiles.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/24/example2drawio.png" style="width: 231px; height: 168px;" />
<pre>
<strong>Input:</strong> tiles = [[10,11],[1,1]], carpetLen = 2
<strong>Output:</strong> 2
<strong>Explanation:</strong> Place the carpet starting on tile 10. 
It covers 2 white tiles, so we return 2.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= tiles.length &lt;= 5 * 10<sup>4</sup></code></li>
	<li><code>tiles[i].length == 2</code></li>
	<li><code>1 &lt;= l<sub>i</sub> &lt;= r<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
	<li><code>1 &lt;= carpetLen &lt;= 10<sup>9</sup></code></li>
	<li>The <code>tiles</code> are <strong>non-overlapping</strong>.</li>
</ul>

class Solution:
    def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
        tiles.sort()
        n = len(tiles)

        i = j = 0
        cover = partial = ans = 0

        while i<n and j <n:
            if tiles[i][0]+carpetLen > tiles[j][1]:
                partial += tiles[j][1]-tiles[j][0] +1
                ans = max(ans,partial)
                j+=1
            else:
                cover = partial + max(0,tiles[i][0]+carpetLen-tiles[j][0])
                partial -= (tiles[i][1]-tiles[i][0]+1)
                i+=1
                ans = max(ans,cover)

        return ans



        # start = tiles[0][0]
        # end = tiles[-1][1]
        # size = end-start+1

        # sweep = [0]*(size)


        # for i in range(n):
        #     tile = tiles[i]
        #     for j in range(tile[0],tile[1]+1):
        #         sweep[j-start] = 1

        # for l in range(1,size):
        #     sweep[l]+=sweep[l-1]

        # ans = 0
        # print(sweep)

        # for k in range(size):
        #     if k+carpetLen<=size:
        #         ans = max(ans, sweep[k+carpetLen-1]-sweep[k]+1)
        #         print(k,ans)

        # return ans



        # stack = [tiles[0]]

        # for i in range(1,n):
        #     tile = tiles[i]
        #     if tile[0] == stack[-1][1]+1:
        #         stack[-1][1] = tile[1]
        #     else:
        #         stack.append(tile)

        # ans = 0

        # m = len(stack)

        # for i in range(m):
        #     white = stack[i][1]-stack[i][0]+1
        #     if white > ans:
        #         ans = min(white,carpetLen)

        # return ans

        
        
844