Problem:


Score : 400 points

Problem Statement

Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.

He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:

a < b + c

b < c + a

c < a + b

How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.

Constraints

All values in input are integers.

3 \leq N \leq 2 \times 10^3

1 \leq L_i \leq 10^3

Input

Input is given from Standard Input in the following format:

N
L_1 L_2 ... L_N

Constraints

Print the number of different triangles that can be formed.

Sample Input 1

4
3 4 2 1

Sample Output 1

1

Only one triangle can be formed: the triangle formed by the first, second, and third sticks.

Sample Input 2

3
1 1000 1

Sample Output 2

0

No triangles can be formed.

Sample Input 3

7
218 786 704 233 645 728 389

Sample Output 3

23



Sample input:
4
3 4 2 1


Sample output:
1

Submission status: Accepted

Solution code:
import bisect
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)

n = int(input())
l = [int(item) for item in input().split()]
l.sort()

ans = 0
for i, a in enumerate(l):
    for j in range(i+1, n):
        b = l[j]
        lower = max(a-b, b-a)
        upper = a + b
        d = bisect.bisect_right(l, lower)
        u = bisect.bisect_left(l, upper)
        double = 0
        if d <= i < u:
            double += 1
        if d <= j < u:
            double += 1
        ans += max(0, u - d - double)

print(ans // 3)

Submission status: Accepted

Solution code:
N=int(input())
L=list(map(int,input().split()))
dic=[0]*1005
izyo=[0]*1005#index以上の長さを持つ総計
for x in L:
	dic[x]+=1
ruike = 0
for x in range(1000,0,-1):
	ruike += dic[x]
	izyo[x] = ruike
ans=0
for a in range(1000,0,-1):#a>=b>=c
	#a=bを考える
	#  a=b=cを考える
	ans+=dic[a]*(dic[a]-1)*(dic[a]-2)//6
	#if ans>0:print("~a:",a,"ans",ans)
	#  a=b>cを考える
	ans+=dic[a]*(dic[a]-1)//2*(izyo[1]-izyo[a])
	#if ans>0:print("-a:",a,"ans",ans)
	
	#a>bを考える
	for b in range(a-1,a//2,-1):
		#b=cを考える
		ans+=dic[a]*dic[b]*(dic[b]-1)//2
		#if ans>0:print("^a:",a,"ans",ans)
		#b>cを考える
		ans+=dic[a]*dic[b]*(izyo[a-b+1]-izyo[b])
		#if ans>0:print("#a:",a,"ans",ans)
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
a = list(map(int,input().split()))
a.sort()
ans = 0
for r in range(n-1,-1,-1):
  m = r
  for l in range(n):
    if l == m and m + 1 < r:
      m += 1
    else:
      while True:
        if a[l] + a[m-1] > a[r] and l < m-1:
          m -= 1
        else:
          break
    if l < m < r:
      ans += r - m
      #print(l,m,r)
print(ans)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

N = int(input())
L = list(map(int,input().split()))
L.sort()

ans = 0
for f in range(N-2):
	fl = L[f]
	s = f+1
	t = f+2
	while s<=N-2:
		sl = L[s]
		# print(f,s)
		if t<=N-1:
			while fl+sl>L[t]:
				t += 1
				if t==N: break
		ans += t-(s+1)
		# print(f,s,t,'',(t-(s+1)))
		s += 1

print(ans)

Submission status: Accepted

Solution code:
# 小さい二本を固定して残りの一本を二分木で探索 O(N ^ 2logN)

def input():
    import sys
    return sys.stdin.readline().rstrip()


def main():
    import math
    import collections
    import itertools
    import bisect

    n = int(input())
    ls = sorted(list(map(int, input().split())))

    ans = 0
    for l1 in range(n - 2):
        for l2 in range(l1 + 1, n - 1):
            check_l = ls[l1] + ls[l2]
            ans += max(bisect.bisect_left(ls, check_l) - (l2 + 1), 0)
            # print(ls[l1], ls[l2], bisect.bisect_left(ls, check_l) - (l2 + 1))
            
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n=int(input())
l=list(map(int,input().split()))
from bisect import bisect_left,bisect_right
l.sort()
a=0
for i in range(n-2):
  for j in range(i+1,n-1):
    a+=bisect_left(l,l[i]+l[j])-j-1
print(a)

Submission status: Accepted

Solution code:
import bisect
import sys

input = sys.stdin.readline


def read_i():
    return list(map(int, input().split()))


n = int(input())
ls = sorted(read_i())
ls2 = ls[::-1]
res = 0
for i, x in enumerate(ls2):
    for j, y in enumerate(ls2[i + 1:], i + 1):
        if 2 * y < x:
            break
        res += n - j - 1 - bisect.bisect(ls[:-(j + 1)], x - y)
print(res)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from bisect import bisect_right, bisect_left
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    n = int(input())
    l = sorted(map(int, input().split()))

    o = 0
    c = []

    for i in range(n):
        for j in range(i):
            a, b = l[i], l[j]

            s = bisect_right(l, a - b)
            e = bisect_left(l, a + b)

            o += max(0, e - max(s, i + 1))

    print(o)


# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N = int(input())
L = [int(l) for l in input().split()]

L.sort()

S = [0]*(L[-1]+L[-2]+2)

for i in range(N):
    if i < N-1:
        for j in range(L[i], L[i+1]):
            S[j] = i+1
    else:
        for j in range(L[-1], len(S)):
            S[j] = i+1
        
ans = 0
for i in range(N-1):
    for j in range(i+1, N):
        m = abs(L[j]-L[i])
        M = L[j]+L[i]
        ans += S[M-1]-S[m]
        if m < L[i] < M:
            ans -= 1
        if m < L[j] < M:
            ans -= 1
            
print(ans//3)

Submission status: Accepted

Solution code:
#  --*-coding:utf-8-*--

import bisect

def main():
    N = int(input())
    L = sorted(map(int, input().split()))

    n = 0
    for i, a in enumerate(L):
        for j, b in enumerate(L[i+1:]):
            n += max(0, bisect.bisect_left(L, a+b)-(j + i + 2))

    print(n)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N=int(input())
L=list(map(int,input().split()))
L.append(0)
L.append(10**9)
L.sort()

#print(L)

ans=0
import bisect

for a in range(1,N):
    for b in range(a+1,N+1):
        c=bisect.bisect_left(L,L[a]+L[b])
        if L[c]>=L[a]+L[b]:
            c-=1
        ans+=(c-b)
        #print(a,b,c)
print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import bisect


def solve(N, L):
    L = sorted(L)
    llen = len(L)
    # print(L)
    ans = 0
    for i in range(llen):
        for j in range(i+1, llen):
            k = bisect.bisect_left(L, L[i]+L[j], j+1)
            n = k - (j+1)
            # print(i, j, k, n)
            ans += n
    return ans


if __name__ == '__main__':
    N = int(input())
    L = list(map(int, input().split()))

    ans = solve(N, L)

    print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect

# スペース区切りの整数の入力
n = int(input())
l_list = input().split(" ")
l_int_list = []
for item in l_list:
    l_int_list.append(int(item))

l_int_list.sort()

count = 0


for i in range(len(l_int_list)):
    for j in range(i+1, len(l_int_list)):
        index = bisect.bisect_left(
            l_int_list, l_int_list[i]+l_int_list[j], j+1, len(l_int_list))
        count += index - j - 1

print(count)

Submission status: Accepted

Solution code:
import bisect as bis

N = int(input())
L = sorted(list(map(int, input().split())))

res = 0
for i, a in enumerate(L):
    for k, b in enumerate(L[i + 1:]):
        j = k + i + 1

        left = b - a
        right = a + b

        index_l = bis.bisect_right(L, left, j)
        index_r = bis.bisect_left(L, right, j)
        if index_l == N - 1:
            break

        res += index_r - index_l - 1
print(res)

Submission status: Accepted

Solution code:
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)


# compiled by pythran
'''
#pythran export main2()
import numpy as np
i8 = np.int64
i4 = np.int32


def solve(L):
    ans = 0
    for n in range(L.shape[0] - 3):
        j = n + 2
        for i in range(n + 1, L.shape[0] - 2):
            while L[n] + L[i] > L[j] and j < L.shape[0]:
                j += 1
            ans += j - i - 1
    return ans


def main2():
    stdin = open('/dev/stdin')
    N = int(stdin.readline())
    L = np.empty(N + 1, i8)
    for i, c in enumerate(map(int, stdin.readline().split())):
        L[i] = c
    L[N] = 2000
    L = np.sort(L)
    ans = solve(L)
    print(ans)
'''

Submission status: Accepted

Solution code:
def solve(lengths):
    # O(n**2) solution?
    # if we have a, b , with a > b
    # then a < c + b, c < a + b -> a - b < c < a + b is the only condition
    # let's say we iterate from max b and max a , so there will be no duplicates.
    # the diff b - a is the only important thing, since a + b will always be bigger than c
    # So we could do DP on this.

    c_counts = {}
    lengths.sort(reverse=True)
    ans = 0
    for i in range(len(lengths)):
        for j in range(i + 1, len(lengths)):
            a, b = lengths[i], lengths[j]
            c_limit = (j, a - b)
            if c_limit in c_counts:
                ans += c_counts[c_limit]
                continue
            c_count = 0
            for k in range(j + 1, len(lengths)):
                c = lengths[k]
                if c > a - b:
                    c_count += 1
                else:
                    # Descending so..
                    break
            c_counts[c_limit] = c_count
            ans += c_count
    return ans


if __name__ == "__main__":
    n = int(input())
    l_s = [int(l) for l in input().split(' ')]
    print(solve(l_s))