Problem:
 Score : 100 points    Problem Statement There are three airports A, B and C, and flights between each pair of airports in both directions.  A one-way flight between airports A and B takes P hours, a one-way flight between airports B and C takes Q hours, and a one-way flight between airports C and A takes R hours.  Consider a route where we start at one of the airports, fly to another airport and then fly to the other airport.  What is the minimum possible sum of the flight times?      Constraints  1 \leq P,Q,R \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  P  Q  R       Output Print the minimum possible sum of the flight times.        Sample Input 1 1 3 4      Sample Output 1 4   The sum of the flight times in the route A \rightarrow B \rightarrow C: 1 + 3 = 4 hours  The sum of the flight times in the route A \rightarrow C \rightarrow C: 4 + 3 = 7 hours  The sum of the flight times in the route B \rightarrow A \rightarrow C: 1 + 4 = 5 hours  The sum of the flight times in the route B \rightarrow C \rightarrow A: 3 + 4 = 7 hours  The sum of the flight times in the route C \rightarrow A \rightarrow B: 4 + 1 = 5 hours  The sum of the flight times in the route C \rightarrow B \rightarrow A: 3 + 1 = 4 hours   The minimum of these is 4 hours.       Sample Input 2 3 2 3      Sample Output 2 5

Solution (Python):
p, q, r = map(int, input().split())
print(p + q + r - max(p, q, r))

Solution (Python):
P,Q,R = list(map(int, input().split()))

print(P+Q+R-max(P,Q,R))

Solution (Python):
p,q,r = map(int,input().split())
print(min(p+q,p+r,q+r))

Solution (Python):
a= list(map(int,input().split()))
a.sort()
print(a[0]+a[1])

Solution (Python):
import math
 
a,b,c = list(map(int, input().split()))
print(min(a+b,b+c,c+a))

Solution (Python):
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, R+P))

Solution (Python):
A = list(map(int, input().split()))
print(sum(A) - max(A))

Solution (Python):
p, q, r = (int(i) for i in input().split())
ans = min(p+q, q+r, r+p)
print(ans)

Solution (Python):
a,s,d=map(int,input().split())
print(min(a+s,s+d,a+d))

Solution (Python):
p,q,r = map(int,input().split())
print(p + q + r - max(p,q,r))

Solution (Python):
import numpy as np
from collections import defaultdict
from functools import reduce




p, q, r = map(int, input().split())

print(min(p+q, q+r, r+p))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

Solution (Python):
P,Q,R = list(map(int, input().split()))

print(P+Q+R-max(P,Q,R))

Solution (Python):
P, Q , R = map(int, input().split())
print(min(P+Q, Q+R, R+P))

Solution (Python):
T = list(map(int, input().split()))
T.sort()
print(T[0]+T[1])

Solution (Python):
P, Q, R = map(int, input().split())
print(min(P + Q, P + R, Q + R))

Solution (Python):
P, Q, R = map(int, input().split())
print(P+Q+R-max(P,Q,R))

Solution (Python):
p,q,r=map(int,input().split())
print(sum([p,q,r])-max(p,q,r))

Solution (Python):
a = list(map(int,input().split()))
a.sort()
print(sum(a[:2]))

Solution (Python):
p=sorted([int(i) for i in input().split()])
print(p[0]+p[1])

Solution (Python):
P, Q, R =map(int,input().split())

print(min(P+Q, Q+R, R+P))

Solution (Python):
P, Q, R = map(int, input().split())

print (min(P+Q, Q+R, R+P))

Solution (Python):
P = [int(_) for _ in input().split()]
P = sorted(P)
print(P[0]+P[1])

Solution (Python):
p, q, r = map(int, input().split())
print(min(p + q, q + r, r + p))

Solution (Python):
p = list(map(int,input().split()))
p.sort()
print(p[0]+p[1])

Solution (Python):
p, q, r = map(int, input().split())
ans = min([p+q, q+r, r+p])
print(ans)

Solution (Python):
p,q,r = map(int,input().split())
print(p+q+r -max(p,q,r))

Solution (Python):
p,q,r=map(int,input().split())
print(min(p+q,p+r,r+q))

Solution (Python):
P, Q, R = map(int, input().split())
print(min([P+Q, Q+R, R+P]))

Solution (Python):
P, Q, R = list(map(int, input().split()))

print(P + Q + R - max(P, Q, R))

Solution (Python):

import sys
from operator import itemgetter






















input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())



def iterate_tokens():
    for line in sys.stdin:
        for word in line.split():
            yield word


if __name__ == '__main__':

    tokens = iterate_tokens()
    P = int(next(tokens))  
    Q = int(next(tokens))  
    R = int(next(tokens))  

    
    print(min(P+Q,Q+R,R+P))

Solution (Python):
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsm = lambda: map(str, sys.stdin.readline().split())
nsl = lambda: list(nsm())

p, q, r = nm()

print(min(p + q, q + r, r + p))

Solution (Python):
a=list(map(int, input().split()))
a.sort()
print(a[0]+a[1])

Solution (Python):
P, Q, R = map(int, input().split())

print(min(P + Q, Q + R, R + P))

Solution (Python):
a,b,c=map(int,input().split())
print(min(a+b,a+c,b+c))

Solution (Python):

A = list(map(int,input().split()))
print(sum(A)-max(A))

Solution (Python):

import sys


def solve(P: int, Q: int, R: int):
    ret = min(P + Q, Q + R, P + R)
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    P = int(next(tokens))  
    Q = int(next(tokens))  
    R = int(next(tokens))  
    solve(P, Q, R)

if __name__ == '__main__':
    main()

Solution (Python):

from sys import stdin




def _li(): return list(map(int, stdin.readline().split()))
def _li_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def _lf(): return list(map(float, stdin.readline().split()))
def _ls(): return stdin.readline().split()
def _i(): return int(stdin.readline())
def _f(): return float(stdin.readline())
def _s(): return stdin.readline()[:-1]


P, Q, R = _li()
print(min(P+Q, Q+R, R+P))

Solution (Python):
a,b,c=map(int,input().split())
print(min(a+b,b+c,c+a))

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
Max = sys.maxsize
def l():
	return list(map(int,input().split()))
def m():
	return map(int,input().split())
def s(x):
	a = []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa == x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x):
	return " ".join(map(str,x))

x = l()

x.sort()

print(x[0]+x[1])

Solution (Python):
l=list(map(int,input().split()))
print(sum(l)-max(l))

Solution (Python):
arr = list(map(int, input().split()))

print(sum(arr) - max(arr))

Solution (Python):
P,Q,R=map(int, input().split())
print(min(P+Q,P+R,Q+R))

Solution (Python):
A = [int(a) for a in input().split()]
print(sum(A)-max(A))

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

P, Q, R = MAP()

print(min(P+Q, P+R, Q+R))

Solution (Python):
import bisect
import operator
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")

P, Q, R = list(map(int, sys.stdin.readline().split()))

print(P + Q + R - max(P, Q, R))

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q, q+r, p+r))

Solution (Python):
p = list(map(int, input().split()))
p.sort()
ans = p[0]+p[1]
print(ans)

Solution (Python):
a,b,c = map(int,input().split())
L = [a,b,c]
L.sort()
print(L[0]+L[1])

Solution (Python):
p,q,r = map(int, input().split())

print(min(p+q, q+r, r+p))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    p,q,r = LI()
    print(p+q+r-max(p,q,r))
    return


def B():
    n = I()

    return


def C():
    n = I()

    return


def D():
    n = I()

    return


def E():
    n = I()

    return


def F():
    n = I()

    return


if __name__ == "__main__":
    A()

Solution (Python):
import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
    if f:
        print('Yes')
    else:
        print('No')
def Y(f):
    if f:
        print('YES')
    else:
        print('NO')

a = list(map(int,input().split()))
a = sorted(a)
print(sum(a[:-1]))

Solution (Python):
a,b,c = map(int,input().split())

print(a+b+c-max(a,b,c))

Solution (Python):
import sys
input = sys.stdin.readline
ri = lambda: int(input())


rl = lambda: map(int,input().split())
rr = lambda N: [list(l) for l in zip(*[rl() for _ in range(N)])]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18
MOD = 10**9+7

P,Q,R=rl()
print(P+Q+R-max([P,Q,R]))

Solution (Python):
import math
import fractions
import copy

def j(q):
    if q==1: print("YES")
    elif q == 0:print("NO")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def printrow(a):
    for i in a:
        print(i)
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)



p,q,r= (int(i) for i in input().split())       










print(min(p+q,q+r,r+p))

Solution (Python):











import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    A, B, C = MI()
    print(A + B + C - max((A, B, C)))
    
    
if __name__ == '__main__':
    main()

Solution (Python):
p,q,r = map(int,input().split())
print(min(p+q, q+r, r+p))