# ödev algoritma

```def find_max_gain_alignment(arr1, arr2, gain_matrix):
m = len(arr1)
n = len(arr2)
dp = [[0] * (n + 1) for _ in range(m + 1)]
directions = [[None] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
gain = gain_matrix[i-1][j-1]
dp[i][j] = max(dp[i-1][j-1] + gain, dp[i][j-1], dp[i-1][j])
if dp[i][j] == dp[i-1][j-1] + gain:
directions[i][j] = &quot;diagonal&quot;
elif dp[i][j] == dp[i][j-1]:
directions[i][j] = &quot;left&quot;
else:
directions[i][j] = &quot;up&quot;
aligned_arr1 = []
aligned_arr2 = []
i=m
j=n
while i &gt; 0 and j &gt; 0:
if directions[i][j] == &quot;diagonal&quot;:
aligned_arr1.append(arr1[i-1])
aligned_arr2.append(arr2[j-1])
i -= 1
j -= 1
elif directions[i][j] == &quot;left&quot;:
aligned_arr1.append(None)
aligned_arr2.append(arr2[j-1])
j -= 1
else:
aligned_arr1.append(arr1[i-1])
aligned_arr2.append(None)
i -= 1
aligned_arr1.reverse()
aligned_arr2.reverse()
return aligned_arr1, aligned_arr2
# &Ouml;rnek kullanım
arr1 = [1, 2, 3, 4, 5]
arr2 = [2, 4, 6, 8, 10]
gain_matrix = [[3, 2, 1, 4, 5],
[2, 5, 6, 1, 3],
[4, 2, 1, 5, 3],
[1, 6, 4, 3, 2],
[3, 1, 2, 4, 5]]
aligned_arr1, aligned_arr2 = find_max_gain_alignment(arr1, arr2, gain_matrix)
print(&quot;Dizi 1:&quot;, aligned_arr1)
print(&quot;Dizi 2:&quot;, aligned_arr2)
A) dp[i][j] = max(dp[i-1][j-1] + gain_matrix[i-1][j-1], dp[i][j-1], dp[i-1][j])
def find_max_gain_alignment(arr1, arr2, gain_matrix):
m = len(arr1)
n = len(arr2)
# Dinamik programlama tablosu
dp = [[0] * (n + 1) for _ in range(m + 1)]
# Geri izleme i&ccedil;in y&ouml;nler
directions = [[None] * (n + 1) for _ in range(m + 1)]
# Dinamik programlama tablosunu doldurma
for i in range(1, m + 1):
for j in range(1, n + 1):
gain = gain_matrix[i-1][j-1] # Kazan&ccedil; matrisinden ilgili kazan&ccedil; değerini al
dp[i][j] = max(dp[i-1][j-1] + gain, dp[i][j-1], dp[i-1][j])
# En y&uuml;ksek kazan&ccedil;lı yolu belirleme
if dp[i][j] == dp[i-1][j-1] + gain:
directions[i][j] = &quot;diagonal&quot;
elif dp[i][j] == dp[i][j-1]:
directions[i][j] = &quot;left&quot;
else:
directions[i][j] = &quot;up&quot;
# En y&uuml;ksek kazan&ccedil;lı ardışıl alt dizi hizalamasını bulma
aligned_arr1 = []
aligned_arr2 = []
i=m
j=n
while i &gt; 0 and j &gt; 0:
if directions[i][j] == &quot;diagonal&quot;:
aligned_arr1.append(arr1[i-1])
aligned_arr2.append(arr2[j-1])
i -= 1
j -= 1
elif directions[i][j] == &quot;left&quot;:
aligned_arr1.append(None)
aligned_arr2.append(arr2[j-1])
j -= 1
else:
aligned_arr1.append(arr1[i-1])
aligned_arr2.append(None)
i -= 1
aligned_arr1.reverse()
aligned_arr2.reverse()
return aligned_arr1, aligned_arr2
# &Ouml;rnek kullanım
arr1 = [1, 2, 3, 4, 5]
arr2 = [2, 4, 6, 8, 10]
gain_matrix = [[3, 2, 1, 4, 5],
[2, 5, 6, 1, 3],
[4, 2, 1, 5, 3],
[1, 6, 4, 3, 2],
[3, 1, 2, 4, 5]]
aligned_arr1, aligned_arr2 = find_max_gain_alignment(arr1, arr2, gain_matrix)
print(&quot;Dizi 1:&quot;, aligned_arr1)
print(&quot;Dizi 2:&quot;, aligned_arr2)
Dinamik programlama algoritmasının zaman ve yer karmaşıklığı şu şekilde hesaplanabilir:
- Zaman Karmaşıklığı: Dinamik programlama tablosunu doldurmak i&ccedil;in kullanılan iki for d&ouml;ng&uuml;s&uuml;,
m ve n değerlerine bağlı olarak &ccedil;alışır. Her bir h&uuml;creyi hesaplama işlemi sabit bir zaman alır.
Dolayısıyla, zaman karmaşıklığı O(mn) olur.
- Yer Karmaşıklığı: Dinamik programlama tablosu, m+1 satır ve n+1 s&uuml;tundan oluşur, yani (m+1) x
(n+1) boyutundadır. Bu nedenle, yer karmaşıklığı O(mn) olur.
&Ouml;zetle, dinamik programlama algoritmasının zaman ve yer karmaşıklığı O(mn) olarak hesaplanır.
```